[[:oktatas:programozás:Cpp|< Cpp]]

====== A C++ nyelv ======

  * **Szerző:** Sallai András
  * Copyright (c) Sallai András, 2011, 2014
  * Licenc: [[https://creativecommons.org/licenses/by-sa/4.0/|CC Attribution-Share Alike 4.0 International]]
  * Web: https://szit.hu


===== Bevezetés =====

==== Fejlesztői környezet ====

A forráskód elkészítéséhez a CodeBlocks fejlesztő eszközt használjuk, amely a következő oldalon érhető el:

  * http://codeblocks.org


Ha a gépeden nincs MingW telepítve akkor ez a változat szükséges: codeblocks-10.05mingw-setup.exe

Ha CodeBlocksot telepítesz, a használható fejlécállományokat itt találod:
  c:\Program Files\CodeBlocks\MinGW\lib\gcc\mingw32\4.7.1\include\c++\
==== Fordító ====

A forráskód lefordításához a GCC fordítót használjuk, amelynek Windowsos megvalósítása a MingW32. 
A MinGW32 fordító feltelepíthető külön is a következő oldalról: 
  * http://mingw.org


Egyéb fordítók
  * Intel C++ Compiler http://en.wikipedia.org/wiki/Intel_C%2B%2B_Compiler
  * Visual C++ http://en.wikipedia.org/wiki/Visual_C%2B%2B
  * Borland C++ Compiler http://en.wikipedia.org/wiki/Borland_C%2B%2B
  * Watcom C++ Compiler http://en.wikipedia.org/wiki/Watcom_C_compiler
  * Még több C++ fordító: http://en.wikipedia.org/wiki/C%2B%2B_compiler#C.2FC.2B.2B_compilers

==== Szabvány ====

=== Amit használunk ===

  * http://www.iso.org/iso/catalogue_detail.htm?csnumber=38110


=== Legújabb szabvány ===

A fordítók csak részben ismerik (2011)

  * http://www.iso.org/iso/iso_catalogue/catalogue_tc/catalogue_detail.htm?csnumber=50372
  * http://en.wikipedia.org/wiki/C++0x
    
===== Történet =====


A C++ nyelv kifejlesztője: Bjarne Stroustrup (Dánia)
  * http://hu.wikipedia.org/wiki/Bjarne_Stroustrup

2003-as szabvány:
  * http://www.iso.org/iso/catalogue_detail.htm?csnumber=38110

^ Év ^ C  szabvány  ^^  C++ szabvány  ^^
| 2011 | | | ISO/IEC 14882:2011 | C++11 vagy C++0x |
| 2007 | ISO/IEC 9899:1999/Cor 3:2007 (A C99 harmadik javítása) | | ISO/IEC TR 19768:2007 \\ Kiterjesztések | C++TR1 |
| 2004 | ISO/IEC 9899:1999/Cor 2:2004 \\ (A C99 második javítása) | | | |			
| 2003 | | | ISO/IEC 14882:2003 | C++03 |
| 2001 | ISO/IEC 9899:1999/Cor 1:2001 \\ (A C99 első javítása) | | | |
| 1999 | ISO/IEC 9899:1999 | C99 | | |
| 1998 | | | ISO/IEC 14882:1998 | C++98 |
| 1996 | ISO/IEC 9899:1990/Cor 2:1996 \\ (A C90 második javítása) | | | |
| 1995 | ISO/IEC 9899:1990/Amd 1:1995 \\ (Irányadó javítás NA-ről C90-re) | C95 | | |
| 1994 | ISO/IEC 9899:1990/Cor 1:1994 \\(A C90 első javítása) | | | |
| 1990 | ISO/IEC 9899:1990 \\(A C89 ISO szabvány lesz) | C90 | | |
| 1989 | ANSI X3.159-1989 \\(ANSI C) | C89 | | |
| 1983 | | | Bjarne Stroustrup C++ | |
| 1978 | nincs hivatalos szabvány - Kernighan & Ritchie C | | | |

===== Helló Világ =====
==== A "Helló Világ!" nevű program forráskódja ====

<code cpp hello.cpp>
#include <iostream>
using namespace std;
int main()
{
  cout << "Helló Világ" << endl;
  return 0;
}
</code>

=== #include <iostream> ===

Egy hesmárk (#) azt jelenti preprocessor direktíva következik. Ezek nem általános kódsorok, 
de a fordító számára megmondják, hogy ezeket a sorokat előre dolgozza fel. 

A #include <iostream> sor azt mondja, hogy a lefordítandó programba fordítsuk bele 
az iostream állományt is.

=== using namespace std; ===
Az std névtér használata. A C++ függvényei névterekbe vannak csoportosítva. 
A using namespace std; utasítással azt mondjuk, hogy szeretnénk az std névtérben
lévő utasításokat használni.



=== int main() ===

A főfüggvény definíciójának kezdete. Az elején az int, azt jelenti, hogy 
a program végrehajtás után egy egész számmal tér vissza. 

=== cout << "Helló Világ" << endl; ===

A cout egy utasítás, amely a folyamként átadott adatokat a képernyőre 
visszhangozza. A "<<" karakterek mondják meg, hogy az utána következő
adatot a cout vegye át folyamként. Az endl is kiíratásra kerül, amely
egy sortörést reprezentál. 

=== return 0; ===

A főfüggvény vége. A programot arra utasítja, hogy 0 értékkel térjen vissza. 

=== Lehetséges kiterjesztések ===
A forrásállományok kiterjesztése platformonként változhat. A szokásos kiterjesztések:
  .C, .cc, .cpp, .cxx

Fejlécállományok a következők lehetnek:
  .h, .hpp, hxx vagy kiterjesztés nélküli

A szabványos C++ könyvtárak kiterjesztés nélküliek. CodeBlocksal telepített MinGW esetén a helyük:
  c:\Program Files\CodeBlocks\MinGW\lib\gcc\mingw32\4.7.1\include\c++\

==== Egy sor ====
A fenti program a sorait az átláthatóság miatt írtuk több sorba. 
Egy ilyen program függvény része, leírható akár egyetlen sorként is:

<code cpp>
int main() { cout << "Helló Világ" << endl; return 0; }
</code>

A C++ nyelven mindent utasítást pontosvesszővel (;) zárunk. 
Ez jelöli az utasítás végét, így biztosítva, hogy egy
sorba több utasítás is írható. 

===== Kivitel =====

<code cpp>
#include <iostream>
</code>

Az iostream állományban lévő függvényeket szeretném használni.


<code cpp>
cout << "karaktersorozat" << endl;
</code>

A cout a képernyőre írja a paraméterként megadott adatokat. Idézőjelek közzé írjuk a kiírni kívánt karaktersorozatot. Az endl sortörést helyez el a képernyőn.

Az endl egy sortörést jelöl. Ha két képernyőre írató utasításom van, és az egyik végén nincs endl akkor ott nem lesz sortörés. Próbáljuk ki a következő programot:

<code cpp egysor.cpp>
#include <iostream>
using namespace std;
int main()
{
  cout << "Helló Világ";
  cout << "Egy C++ program vagyok" << endl;
  return 0;
}
</code>



===== Escape szekvenciák =====

^ Escape szekvencia ^ Leírás ^
| \' | felsővessző (byte 0x27) |
| \" | idézőjel (byte 0x22) |
| <nowiki>\\</nowiki> | backslash (byte 0x5c) |
| \0 | nul karakter (byte 0x00) |
| \a | csengőhang (byte 0x07) |
| \b | backspace (byte 0x08) |
| \f | lapdobás - form feed (byte 0x0c) |
| \n | soremelés - line feed (byte 0x0a) |
| \r | kocsi vissza - carriage return (byte 0x0d) |
| \t | vízszintes tabulátor (byte 0x09) |
| \v | függőleges tabulátor (byte 0x0b) |
| \nnn | oktális bájt (nnn) |
| \nn | hexadecimális bájt (nn) |








===== Változók, adattípusok =====

==== Alaptípusok ====

^  Név  ^  Leírás  ^  Méret*  ^  Tartomány*  ^
| char  | Karakter vagy kis egész | 1byte | signed: -128 -- 127 unsigned: 0 to 255 |
| short int (short)  | Rövid Egész | 2bytes | signed: -32768 to 32767 unsigned: 0 to 65535 |
| int  | Egész (integer) | 4bytes | signed: -2147483648 -- 2147483647 unsigned: 0 to 4294967295 |
| long int (long) | Hosszú egész (Long integer) | 4bytes | signed: -2147483648 -- 2147483647 unsigned: 0 to 4294967295 |
| bool  | Logikai érték (Boolean) Két értéke lehet: true vagyr false | 1byte | true vagy false |
| float  | Lebegőpontos szám (floating) | 4bytes | +/- 3.4e +/- 38 (~7 számjegy) |
| double  | Dupla pontosságú lebegőpontos szám | 8bytes | +/- 1.7e +/- 308 (~15 számjegy) |
| long double | Hosszú dupla pontosságú lebegőpontos szám | 8bytes | +/- 1.7e +/- 308 (~15 számjegy) |
| wchar_t  | Széles karakter (wide) | 2 vagy 4 bytes | 1 wide karakter |


A C++11 szabvány bevezet két új típust:
  * char16_t - UTF-16 karakter
  * char32_t - UTF-32 karakter
==== Módosítók ====
Módosítják a típust. Sorrendjük mindegy. Egy típusdefinícióban csak
egyszer szerepelhetnek.

=== Előjelváltó ===

  * signed - előjeles értelmezés (ez az alapértelmezett)
  * unsigned - előjel nélküli értelmezés

=== Méret ===

  * short - Célja a jó helykihasználás, amely legkevesebb 16 bites szám lesz.
  * long - Cél, hogy legkevesebb 30 bites legyen
  * long long - Cél, hogy legkevesebb 64 bites legyen (Csak C++11 szabvány)



=== Példa ===

<code cpp>
unsigned short int szam;
</code>

A számváltozó 16 bites előjel nélküli szám lesz. 

<code cpp>
long long int szam;
</code>
A szam változó 8 bájtos lesz.

<code cpp>
long double szam;
</code>
A szam változó 12 bájtos lesz.

==== Limitek ====


A climits állományban a típusok maximális és minimális értéke lekérdezhető. Az int egész típus maximális
értéke például így kérdezhető le:

<code cpp maxint.cpp>
#include <iostream>
#include <climits>
using namespace std;

int main()
{
	cout << INT_MAX << endl;	
	return 0;
}
</code>

További állandók az alábbi táblázatban találhatók:

^ name ^ leírás ^ min. nagyság* ^
| CHAR_BIT | Egy karakterobjektum bitjeinek száma (byte) | 8 |
| SCHAR_MIN | Egy signed char objektum minimumértéke | -127 |
| SCHAR_MAX | Egy signed char objektum maximális értéke | 127 |
| UCHAR_MAX | Egy unsigned char típusú objektum maximális értéke | 255 |
| CHAR_MIN | Egy char típusú objektum minimum értéke | SCHAR_MIN vagy 0 |
| CHAR_MAX | Egy char típusú objektum maximális értéke | SCHAR_MAX vagy UCHAR_MAX |
| MB_LEN_MAX | A bájtok maximális száma egy több bájtos karakter esetén, helyi (locale) beállításokhoz igazodva | 1 |
| SHRT_MIN | Egy short int objektum minimális értéke | -32767 |
| SHRT_MAX | Egy short int objektum maximális értéke | 32767 |
| USHRT_MAX | Egy unsigned short int objektum maximális értéke | 65535 |
| INT_MIN | Egy int típusú objektum minimum értéke | -32767 |
| INT_MAX | Egy int típusú objektum maximum értéke | 32767 |
| UINT_MAX | Egy unsigned int objektum maximum értéke | 65535 |
| LONG_MIN | Egy long int objektum minimum értéke | -2147483647 |
| LONG_MAX | Egy long int maximum értéke | 2147483647 |
| ULONG_MAX | Egy unsigned long int objektum maximum értéke | 4294967295 |


==== Típus kasztolás ====

casting
[UK: ˈkɑːstɪŋ]
[US: ˈkæstɪŋ]

esés,
hajítás,
horgászás,
kimustrálás,
öntés,
öntvény,
szereposztás,
vetemedés



=== Implicit conversion ===

Az implicit konverzióhoz nem szükséges operátor. 
Ez automatikusan teljesül, amikor egy értéket adunk.

Például:
<code cpp>
short a=2000;
int b;
b=a;
</code>




<code cpp>
class A {};
class B { public: B (A a) {} };

A a;
B b=a;
</code>


=== Explicit conversion ===
A C++ erősen típusos nyelv. Néhány típuson explicit konverziót alkalmazhatunk. 

<code cpp>
short a=2000;
int b;
b = (int) a;    // c-stílusú kasztolás
b = int (a);    // függvényszerű jelölés
</code>


<code cpp>
// class type-casting
#include <iostream>
using namespace std;

class CDummy {
    float i,j;
};

class CAddition {
	int x,y;
  public:
	CAddition (int a, int b) { x=a; y=b; }
	int result() { return x+y;}
};

int main () {
  CDummy d;
  CAddition * padd;
  padd = (CAddition*) &d;
  cout << padd->result();
  return 0;
}
</code>

  * http://cplusplus.com/doc/tutorial/typecasting/

===== Literális állandók =====

<code cpp>
int a = 3;
double b = 4.5;
char c = 'a';
char d = '\n';
string e = "szilva";
</code>

Az egyenlőség jel jobb oldalán lévő értékek állandók. Állandók mert a
futási időben ezeket nem változtatjuk meg. Mégpedig literális állandók.


|  255, 0377, 0xff  |  Egészek (decimális, oktális, hex)  |
|  2147483647L, 0x7fffffffl  |  Hosszú, 32-bites egészek  |
|  123.0, 1.23e2  |  dupla pontosságú valós számok  |
|  'a', '\141', '\x61'  |  Karakter (literális, oktális, hex)  |
|  '\n', '\\', '\'', '\<nowiki>"</nowiki>'  |  ÚjSor, visszaperjel, felső vessző, idézőjel  |
|  <nowiki>"</nowiki>szöveg\n<nowiki>"</nowiki>  |  Karaktertömbök \0 lezárással  |
|  <nowiki>"</nowiki>helló<nowiki>"</nowiki> <nowiki>"</nowiki>világ<nowiki>"</nowiki>  |  Összefűzött karaktersorozatok  |
|  true, false  |  logikai állandók 1 és 0  |

<code cpp>
#include <iostream>
using namespace std;
int main()
{
	int a = 0xff; //Hexadecimális szám megadása
	cout << a << endl;	
	return 0;
}
</code>


===== Nevesített állandó =====


<code cpp>
#include <iostream>
using namespace std;
int main()
{
	const int max = 5;
	cout << max << endl;
	return 0;
}
</code>

<code cpp>
#include <iostream>
#define MAX 25
 using namespace std;
 int main()
{	
	cout << MAX << endl;
	return 0;
}
</code>



===== Formázott kivitel =====

Formázott kivitelhez a iomanip fejállományt kell beillesztenünk.

==== Mezőszélesség ====

<code cpp mezo.cpp>
#include <iostream>
#include <iomanip>
using namespace std;

int main()
{
    int szam = 28;

    cout << setw(10) << szam << endl;

    return 0;
}
</code>



==== Kitöltés ====


<code cpp kitoltes.cpp>
#include <iostream>
#include <iomanip>
using namespace std;

int main()
{
    double szam = 28.12345;


    cout << setw(10) << setfill('0') << szam << endl;

    return 0;
}
</code>


==== Precizitás ====

A tizedesek száma lebegőpontos szám esetén:
<code cpp prec.cpp>
#include <iostream>
#include <iomanip>
using namespace std;

int main()
{

    double szam = 2800.1234;


    //cout << setiosflags(ios::fixed) << setprecision(2) << szam << endl;
    cout << setprecision(2) << szam << endl;

    return 0;
}
</code>


Ha fixpontos ábrázolással szeretnénk ábrázolni:
<code cpp prec.cpp>
#include <iostream>
#include <iomanip>
using namespace std;

int main()
{

    double szam = 2800.1234;

    cout << setiosflags(ios::fixed) << setprecision(2) << szam << endl;

    return 0;
}
</code>


==== Vezető nullák ====

<code cpp vezetonulla.cpp>
#include <iostream>
#include <iomanip>
using namespace std;

int main()
{
    int szam = 58;

    cout << setfill('0') << setw(10) << szam << endl;

    return 0;
}
</code>


Dátum kiíratása:
<code cpp datum.cpp>
#include <iostream>
#include <iomanip>
using namespace std;

int main()
{
	int ev = 1995;
	int ho = 1;
	int nap = 1;

	cout << setfill('0');
	cout <<  ev << '.' << setw(2) << ho << '.' << setw(2) << nap << endl;
	
	return 0;
}
</code>


==== Számrendszerek ====
Váltás 10-től eltérő számrendszerbe:

<code cpp valtas.cpp>
#include <iostream>
#include <iomanip>
using namespace std;

int main()
{
	int szam = 15;
	
	cout << "Oktális szám: " << oct << szam << endl;
	cout << "Hexadecimális szám: " << hex << szam << endl;
	
	return 0;
}
</code>


  * http://www.cplusplus.com/reference/iostream/manipulators/
  * http://www.cprogramming.com/tutorial/iomanip.html

==== Tizedes jegyek száma ====


Valós számok esetén a tizedes jegyek számának meghatározása (két tizedesjegy beállítása):
<code cpp>
#include <iostream>
#include <iomanip>

int main()
{
    double a;
    a = 328.2843824;
    
    cout.precision(2);
    cout << fixed << a << endl;
    
    return 0;
}
</code>

<code cpp>
#include <iostream>
#include <iomanip>

int main()
{
    double a;
    a = 328.2843824;
    
    
    cout << setprecision(2) << fixed << a << endl;
    
    return 0;
}
</code>

A fixed beállítja, hogy fixpontos számábrázolást használjunk. 


----
===== Matematikai függvények =====

==== abs() ====
Abszolút érték számítása.

<code c++ p01.cxx>
#include <iostream>
#include <cmath>
using namespace std;
int main() {
	cout << abs(-9) << endl;	
	return 0;
}
</code>


^  Trigonometriai függvények  ^^
|  cos()  |  Koszinusz  |
|  sin()  |  Szinusz  |
|  tan()  |  Tangens  |
|  acos()  |  Arkusz koszinusz  |
|  asin()  |  Arkusz szinusz  |
|  atan()  |  Arkusz tangens  |
|  atan2()  |  Arkusz tangens két paraméterrel  |

^  Hiperbolikusz függvények  ^^
|  cosh()  |  Hyperbolikusz konszinusz  |
|  sinh()  |  Hyperbolikusz szinusz  |
|  tanh()  |  Hyperbolikusz tangens  |
|  acosh()  |  Arkusz hyperbolikusz koszinusz  |
|  asinh()  |  Arkusz hyperbolikusz koszinusz  |
|  atanh()  |  Arkusz hyperbolikusz tangens  |


^  Exponenciális és logratimikus függvények   ^^
|  exp()  |  Exponenciális függvény  |
|  frexp()  |  Együttható és kitevő lekérdezése  |
|  ldexp()  |  Érték generálása együtthatóból és kitevőből  |
|  log()  |  Természetes logaritmus  |
|  log10()  |  10-es alapú (általános) logaritmus  |
|  modf()  |  A tört és egész egész rész számítása  |
|  exp2()  |  bináris exponenciális számítása  |
|  expm1()  |  exponenciális minusz 1  |
|  ilogb()  |  egész bináris logratimus  |
|  log1p()  |  logaritmus plusz 1 |
|  log2()  |  Bináris logaritmus  |
|  logb()  |  lebegőpontos alapú logaritmus  |
|  scalbn()  |  Adott együttható használata lebegőpontosként, adott kitevőn |
|  scalebln()  |  Adott együttható használata lebegőpontosként (long)  |

^  Hatvány függvények  ^^
|  pow()  |  adott hatványra emel  |
|  sqrt()  |  gyökvonás  |
|  cbrt()  |  köbgyök  |
|  hypot()  |  derékszögű háromszög átfogója  |

^  Konstansok  ^^
|  M_PI  |  pi értéke  |

===== Operátorok =====

==== Értékadó (=) ====
Meghatározzuk egy változó értékét.

<code cpp>
a = 5;
</code>

<code cpp>
a = b;
</code>

<code cpp>
a = 2 + (b = 5);
</code>


==== Aritmetikai operátorok ( +, -, *, /, % ) ====

| + | összeadás |
| - | kivonás |
| * | szorzás |
| / | osztás |
| % | maradékképzés |


<code cpp>
a = 11 % 3;
</code>
Az "a" értéke 2 lesz. 



==== Összetett meghatározások (+=, -=, *=, /=, %=, >>=, <<=, &=, ^=, |=) ====

^ kifejezés ^ egyenlő ezzel ^
| valtozo += novekmeny; | valtozo = valtozo + novekmeny; |
| a -= 5; | a = a - 5; |
| a /= b; | a = a / b; |
| egysegar *= egyseg + 1; | egysegar = egysegar * (egyseg + 1); |

==== Inkrementálás és dekrementálás (++, --) ====

A ++ operátor növeli egy változó értékét, a -- pedig csökkenti eggyel. 

<code cpp>
c++;
c+=1;
c=c+1;
</code>
A fenti három utasítások ugyanazt csinálja. Mindegyik növeli a c változó értékét 1-gyel. 


Az inkrementáló és dekrementáló utasításokat írhatjuk a változó neve elé és után is. 
Egy értékadó kifejezés jobboldalán a viselkedésük eltér. 
^  Példa 1  ^  Példa 2  ^
| B=3; \\ A=++B; \\ <nowiki>//</nowiki> A tartalma 4, B tartalma 4 | B=3; \\ A=B++; \\ <nowiki>//</nowiki> A tartalma 3, B tartalma 4 |

A táblázatban leírt példából láthatjuk, hogy ha a ++ operátor a B előtt van (++B), akkor 
előbb növeljük a B változó értékét, és csak az után tesszük azt egyenlővé az A változóval. 
Ha a ++ operátor a B változó után áll, akkor előbb eltároljuk az A változóban a B aktuális
értékét, majd utána növelem a B változó értékét 1-gyel.


==== Összehasonlító operátorok ( ==, !=, >, <, >=, <= ) ====


| == | egyenlő |
| != | nem egyenlő |
| > | nagyobb mint |
| < | kisebb mint |
| >= | nagyobb vagy egyenlő |
| <nowiki><=</nowiki> | kisebb vagy egyenlő |


<code cpp>
(8 == 5)     // az értékelés eredmény hamis (false)
(5 > 4)      // az értékelés eredmény igaz (true)
(3 != 2)     // az értékelés eredmény igaz (true)
(6 >= 6)     // az értékelés eredmény igaz (true)
(3 < 3)      // az értékelés eredmény hamis (false)

</code>

==== Logikai operátorok ( !, &&, || ) ====

=== ! operátor ===

<code cpp>
!(5 == 5)    // értéke false, mert a (5 == 5), és ennek ellenkezőjét kell venni.
!(6 <= 4)    // értéke true, mert (6 <= 4) kifejezés értéke false
!true        // értéke false
!false       // értéke true.
</code>



=== && operátor ===

^ a ^ b ^ a && b ^
| true | true | true |
| true | false | false |
| false | true | false |
| false | false | false |



=== || operátor ===

^ a ^ b ^ a <nowiki>||</nowiki> b ^
| true | true | true |
| true | false | true |
| false | true | true |
| false | false | false |




=== Példák ===

<code cpp>
( (8 == 8) && (2 > 4) )  // értéke false ( true && false )
( (8 == 8) || (2 > 4) )  // értéke true ( true || false )
</code>


==== Feltételes operátor (?) ====

<code cpp>
feltétel ? visszatérési_érték1 : visszatérési_érték2
</code>





<code cpp>
8==3 ? 4 : 3     // visszatérési érték 3, mert 8 nem egyenlő 3-mal
7==5+2 ? 4 : 3   // visszatérési érték: 4, since 7 is equal to 5+2.
6>3 ? a : b      // visszatér a értékével, mivel 6 nagyobb mint 3
a>b ? a : b      // visszatér a nagyobbal, a vagy b-vel
</code>


==== Vessző operátor ( , )====
A vesszőoperátor kettő vagy több kifejezés elválasztására való, ott ahol csak egy kifejezés írható.  

A példa kedvéért egy kód:
<code cpp>
a = (b=3, b+2);
</code>

Először a 3 rendelődik a b változóhoz, majd a b-hez 2-őt adunk, amely a végén a váltózóba kerül.
A végén így a változó értéke 5 lesz. 


==== Bitmódosító operátor ( &, |, ^, ~, <<, >> ) ====

^ operátor ^ asm megfelelő ^ leírás ^
| & | AND | bitenkénti ÉS (AND) |
| <nowiki>|</nowiki> | OR | bitenkénti bezáró VAGY (OR) |
| <nowiki>^</nowiki> | XOR | bitenkénti kizáró VAGY (OR) |
| ~ | NOT | egyes komplemens (bit invertálás) |
| <nowiki><<</nowiki> | SHL | balra tolás |
| <nowiki>>></nowiki> | SHR | jobbra tolás |

==== Nyílt típusmeghatározó operátor ====

Kasztolás néven ismert típusátalakítás. 
<code cpp>
int i;
float f = 3.14;
i = (int) f;
</code>
Az f változóban valós szám van, de az (int) kasztoló operátorral, 
egész típusúvá alakítjuk. 


==== sizeof() ====
Ez az operátor egy paramétert fogad, amely egy típus vagy egy változó. Visszatér annak méretével bájtokban megadva.

Például:
<code cpp> 	
a = sizeof (char);
</code>


===== Konvertálás =====

==== stringstream ====
A stringstream a <sstream> fájlban található és szövegalapú objektumok folyamként való kezelését teszi
lehetővé. Ezzel könnyen átalakíthatunk karaktersorozatot számmá és vissza.


<code cpp convert1.cpp>
#include <iostream>
#include <sstream>
using namespace std;

int main()
{
	cout << "Hi" << endl;
	string str("384");
	int a;
	stringstream(str) >> a;
	cout << a << endl;
	return 0;
}
</code>


<code cpp convert2.cpp>
#include <iostream>
#include <sstream>
using namespace std;

int main()
{
	
	string str;
	float ar;
	
	cout << "Ar: ";
	getline(cin, str);
	stringstream(str) >> ar;
	cout << ar << endl;
	
	return 0;
}
</code>


<code cpp aru.cpp>
#include <iostream>
#include <sstream>
using namespace std;

int main()
{
	
	string str;
	float ar;
	int mennyiseg;
	
	cout << "Ar: ";
	getline(cin, str);
	stringstream(str) >> ar;
	
	cout << "Mennyiseg: " ;
	getline(cin, str);
	stringstream(str) >> mennyiseg;
	
	cout << "Fizetendo: " << ar * mennyiseg << endl;
	
	return 0;
}
</code>


==== atoi ====


<code cpp>
#include <iostream>
#include <cmath>

using namespace std;

int main()
{
	char *str = "123";
	
	int a = atoi(str);
	
	cout << a * 2 << endl;

	return 0;
}
</code>


===== Bevitel =====
==== Egész szám bekérése ====

<code cpp>
int a;
cin >> a;
</code>


==== Karakter bekérése ====
A cin segítségével egy karaktert vagy egy karaktersorozatot kérhetünk be a billentyűzetről.

<code cpp karakterbe.cpp>
#include <iostream>
using namespace std;
int main()
{
    char cha, chb;
    
    cout << "Karakter: ";
    cin >> cha;
    cin.ignore();
    cout << "Karakter2: ";
    cin >> chb;


    cout << endl << "Első: " << cha << endl;
    cout << "Második: " << chb << endl;


    return 0;
}
</code>

Karaktersorozat esetén whitespace karakter után a karakterek tárolása megszakad. 
Írhatunk még karaktersorozatokat, de csak a whitespace előtti rész kerül a változóba.
Így ezzel az utasítással csak egy szót kérhetünk be. Mi azonban nem mindig ezt szeretnénk. 
Ha szeretnénk egy egész mondatot bekérni akkor a getline() függvényt használhatjuk. 
A getline() több módon használható.

==== getline() ====

<code cpp mondatbe.cpp>
#include <iostream>

using namespace std;

int main()
{
	cout << "Mondat: ";
	string str;
	getline(cin, str);	
	cout << str << endl;
	return 0;
}
</code>


==== Várakozás egy billentyűnyomásra ====

<code cpp>
cin.get();
</code>
Egy billentyűnyomást vár. A lenyomott billentyűt el is
tárolhatjuk:
<code cpp>
char a = cin.get();
</code>

vagy
<code cpp>
int a = cin.get();
</code>

A lenyomott billentyű egész számként is eltárolható. Ilyenkor az ASCII kódtáblában a billentyűnek megfelelő ASCII kód kerül tárolásra.




===== Vezérlőtevékenységek =====


Egy programkód nem feltétlenül egymás után hajtódik végre. 
Vannak, amelyek végrehajtását bizonyos feltételhez kötjük. 
Vannak, amelyeket többször egymás után szeretnék végrehajtani. 
Vannak olyan utasítások, amelyeket szeretnénk együtt kezelni.

Az együtt kezelendő utasításokat blokkokba szervezzük. 
A blokkokat kapcsos zárójelekkel adjuk meg: 

  { utasítás1; utasítás2; utasítás3;  }


===== Szelekció =====
==== if ====

Általánosságban a legegyszerűbb if feltételes utasítás a következő módon épül fel:
  if (feltétel) utasítások

Az if után zárójelek között megadjuk a feltételt. A zárójel után 
megadunk egy utasítást vagy egy utasításblokkot. 


<code cpp>
if (x == 100)
  cout << "x tartalma 100" ;
</code>


<code cpp>
int a;
cin << a;

if(a < 10)
  cout << "Kisebb mint 10" << endl;
else
  cout << "Nagyobb vagy egyenlő mint 10" << endl;
</code>



<code cpp>
int a;
cin << a;

if(a < 10)
{
  cout << "Kisebb mint 10";
  cout << endl;
}
else
{
  cout << "Nagyobb vagy egyenlő mint 10";
  cout << endl;
}
</code>


==== switch ====


<code cpp>
int a;
cin >> a;

switch(a)
{
  case 3 : cout << "Három" << endl; break;
  case 5 : cout << "Öt" << endl; break;
  case 7 : cout << "Hét" << endl; break;
}
</code>


<code c++ program01.cxx>
#include <iostream>
using namespace std;
int main(int argc, char **argv) {
	char b;
	cin >> b; 
	switch(b) {
		case 'a': 
			cout << "A betű" << endl;
			break;
		case 'b': 
			cout << "B betű" << endl;
			break;
		default:
			cout << "Egyéb" <<endl;
	}
	return 0;
}
</code>



===== Iteráció =====

==== while ====



<code cpp>
int a;
a = 0;
while(a < 10)
{
  cout << "alma" << endl;
  a++;
}
</code>

==== for ====

<code cpp>
int a;
cin >> a;
for(a=0; a < 10; a++)
{
  cout << "alma" << endl;
}
</code>


Ha számokat visszafele szeretnénk megkapni, akkor: <nowiki>n--</nowiki>
<code cpp>
#include <iostream>
using namespace std;
int main ()
{
  for (int n=10; n>0; n--) {
    cout << n << ", ";
  }
  cout << "TUZ!\n";
  return 0;
}
</code>

Az előkészítős részben és a növekményes részben megadható több utasítás a vessző operátor segítségével.
<code cpp>
for ( n=0, i=100 ; n!=i ; n++, i-- )
{
   // amit tenni szeretnénk...
}
</code>


==== do ====

<code cpp>
int i = 1;

do
{
    cout << "alma" << endl;
    i++;
}while (i <= 10);
</code>

===== Ugró utasítások =====
==== break ====

<code cpp>
#include <iostream>
using namespace std;

int main ()
{
  int n;
  for (n=10; n>0; n--)
  {
    cout << n << ", ";
    if (n==3)
    {
      cout << "számlálás leállítása!";
      break;
    }
  }
  return 0;
}
</code>


  10, 9, 8, 7, 6, 5, 4, 3, számlálás leállítása!

==== continue ====

<code cpp>
// continue példa
#include <iostream>
using namespace std;

int main ()
{
  for (int n=10; n>0; n--) {
    if (n==5) continue;
    cout << n << ", ";
  }
  cout << "TUZ!\n";
  return 0;
}
</code>

  10, 9, 8, 7, 6, 4, 3, 2, 1, TUZ!

goto

<code cpp>
// goto példa

#include <iostream>
using namespace std;

int main ()
{
  int n=10;
  ciklus:
  cout << n << ", ";
  n--;
  if (n>0) goto ciklus;
  cout << "TUZ!\n";
  return 0;
}
</code>

  10, 9, 8, 7, 6, 5, 4, 3, 2, 1, TUZ!


==== Az exit() függvény ====


Az exit() függvény a cstdlib könyvtárban van definiálva.

Az exit() függvény megszakítja a program futását és visszaad az operációs rendszernek 
egy visszatérési értéket. 

Az exit() fejrésze: 	
<code cpp>
void exit (int exitcode);
</code>


===== Tömbök =====

Azonos típusok tárolására használt adatszerkezet.

==== Vektor ====

Egydimenziós tömbök, vagyis kiterjedésük egyirányú.

Pl:
| 3 | 9 | 5 | 8 | 2 | 1 | 4 |

A tömbünk egész számokat tartalmaz. 
De lehet ugyanez valós számokkal

| 2.7 | 0.8 | 1.5 | 5.3 | 9.4 | 1.3 | 5.0 |

Vagy tartalmazhat karaktereket:
| 'c' | 'k' | 'e' | 'r' | 'n' | 'p' | 'b' |


<code cpp>
int egeszSzamok[5];

egeszSzamok[0] = 35;
egeszSzamok[1] = 42;
egeszSzamok[2] = 98;
egeszSzamok[3] = 22;
egeszSzamok[4] = 76;
</code>

Kezdőérték:
<code cpp>
int egeszSzamok[5] = {35, 42, 98, 22, 76};
</code>




==== Mátrix ====


| 3 | 19 | 35 | 18 | 2 | 1 | 4 |
| 9 | 2 | 3 | 5 | 15 | 23 | 2 |
| 18 | 92 | 25 | 38 | 11 | 19 | 42 |
| 33 | 30 | 51 | 82 | 23 | 14 | 44 |


| 3.6 | 19 | 35 | 18 | 2 | 1 | 4 |
| 9 | 2 | 3 | 5 | 15 | 23 | 2 |
| 18 | 92 | 25 | 38 | 11 | 19 | 42 |
| 33 | 30 | 51 | 82 | 23 | 14 | 44 |


<code cpp>
int matrix[4][7];
</code>

===== Fájlkezelés =====

==== Fájlok olvasása, írása ====

<code cpp>
#include <iostream>
#include <fstream>
using namespace std;
int main()
{
    string s;
    ifstream in("test.dat"); //Megnyitás olvasásra
    ofstream out("test2.dat"); //Megnyitás írásra
    while(getline(in, s))		//Olvassunk be egy sort
    cout << s << "\n";			//Írjuk egy másik fájlba
  
    return 0;
}
</code>






==== Fájlok írása másként ====

<code cpp>
#include <iostream>
#include <fstream>
using namespace std;
main()
{
    ofstream f
  
    f.open("test.txt");
    
    if(!f.is_open()) 
    {
      cerr << "A fájlt nem sikerült megnyitni" << endl;
      return;
    }
  
    f << "Kiírnivaló" << endl;
  
    f.close()
  
}
</code>




===== fájlok olvasása másként =====

<code cpp>
#include <iostream>
#include <fstream>
#include <string>
using namespace std;
main()
{
  
    ifstream f
	
    f.open("test.txt");
  
    if(!f.is_open()) 
    {
        cerr << "A fájlt nem sikerült megnyitni" << endl;
        return;
    }
  
    string s;
    while(!f.eof())
    {
        f >> s;
        cout << s << endl;
    }
  
  
    f.close()
  
}
</code>



==== fájl nyitás megint ====

<code cpp>
#include <iostream>
#include <fstream>
using namespace std;


int main() 
{
    long begin,end;
  
    ifstream f ("input.txt");
    
    // GET pointer lekérése
    begin = f.tellg();
  
    // file végére pozícionálunk
    f.seekg (0, ios::end);
    end = f.tellg();
    myfile.close();
   
    // különbség (fajlméret) kiírása
    cout << "Méret: " << (end-begin) << " byte.\n";
  
    return 0;
}
</code>


==== Tagolt olvasás fájlból ====


<code cpp olvas.cpp>
/* Olvasás szóközökkel tagotl fájlból */
#include <iostream>
#include <fstream>

using namespace std;

int main()
{
	ifstream befolyam("adat.txt");
	string str;
	int ar;

	befolyam >> str;
	befolyam >> ar;	
	while(befolyam.good()) 
	{
		cout << str << " ";
		cout << ar << endl;
		befolyam >> str;
		befolyam >> ar;
	}
	return 0;
}
</code>


===== Dinamikus változók =====
Ha egy változót mutatóként hoztunk létre és már nincs rá
szükségünk, lehetőségünk van a memóriafoglalást megszüntetni,
azaz felszabadítani. Ezt a delete utasítással tehetjük meg: 

<code cpp>
#include <iostream>
using namesapce std;
  
main()
{
    int *a;
  
    a = new int;
  
    *a = 3;
  
    cout << *a << endl;
  
    delete(a);
}
</code>

Tömbök felszabadításakor a delete operátor után mindig használjuk az üres szögletes zárójelpárt ('[]'). Ezáltal a tömb minden elemére lefut a destruktor, felszabadítva a dinamikusan lefoglalt memóriaterületeket is. A szögletes zárójelpár nélkül csak az objektumhoz statikusan tartozó memóriaterület szabadul fel. Ha a zárójelbe a tömb méretétől eltérő szám kerül, akkor vagy nem szabadul fel az összes memória, vagy a destruktor olyan objektumra is meghívódik, ami nem is létezett. Az üres zárójelpár használatával ezek elkerülhetőek.




===== Barátok =====

<code cpp>
class a
{
    (...)
    friend globalisfuggvenyneve(parm. lista);
  
};



class b
{
    (...)
    friend class osztalynev;
  
};
</code>


===== Véletlen szám =====

<code cpp>
  #include <ctime>    // time()
  #include <cstdlib>  // srand() és rand()

  srand(time(0));
  int r = (rand() % 10) + 1;  // 1 és 10 közötti szám
</code>




===== Szövegkezelés =====


==== Szöveg darabolása ====


<code cpp>

#include <iostream>
#include <string>
#include <sstream>

using namespace std;

main()
{
    string szoveg = "szilva:körte:barack";

    istringstream szovegfolyam(szoveg);

    string resz;

    while(getline(szovegfolyam, resz, ':'))
	cout << resz << endl;
}

</code>


<code cpp>
#include <iostream>
#include <string>
using namespace std;

int main ()
{
	string line = "rovid vonal a teszteleshez";
	

	// with no arguments
	string s1;
	s1 = "András";
	cout << "s1: " << s1 << endl;

	// copy constructor
	string s2 (s1);
	cout << "s2: " << s2 << endl;

	// one argumen
	string s3 (line);
	cout << "s3: " << s3 << endl;

	// first argumen C string
	// second number of characters
	string s4 (line,10);
	cout << "s4: " << s4 << endl;

	// 1 - C++ string
	// 2 - start position
	// 3 - number of characters
	string s5 (s3,7,5); // copy word 'line' from s3
	cout << "s5: " << s5 << endl;

	// 1 - number characters
	// 2 - character itself
	string s6 (15,'*');
	cout << "s6: " << s6 << endl;

	// 1 - start iterator
	// 2 - end iterator
	string s7 (s3.begin(),s3.end()-5);
	cout << "s7: " << s7 << endl;

	// you can instantiate string with assignment
	string s8 = "Andras";
	cout << "s8: " << s8 << endl;

	return 0;
}
</code>


Darabolás újra:
<code c darbolas3.cpp>
#include <iostream>
#include <string>
#include <sstream>

main()
{
	std::string gyumolcs("alma:szilva:körte:barack");
	std::istringstream iss(gyumolcs);
	std::string token;
	while(getline(iss, token, ':')) {
		std::cout << token << std::endl;
	}
}
</code>

===== Makró =====

Egy kódrészlet, amelynek nevet adunk. Amikor használjuk a nevet a makró kódja behelyettesítődik.
Kétféle makró van. Leginkább abban különböznek, ahogy használatkor kinéznek.

  * Objektumszerű makró, mint amikor egy objektumot használunk
  * Függvényszerű makró, mint amikor egy függvényt használunk

==== Objektumszerű ====

Definiálása:
<code cpp>
#define BUFFER_SIZE 1024
</code>

Használata:
<code cpp>
foo = (char *) malloc (BUFFER_SIZE);
</code>


Egy tömb megadása:
<code cpp>
#define NUMBERS 1, \
                2, \
                3
    int x[] = { NUMBERS };
</code>

Olyan mintha ezt írtuk volna:
<code cpp>
int x[] = { 1, 2, 3 };
</code>


==== Függvényszerű ====


<code cpp>
#define lang_init()  c_init()
</code>


Ezek után, ha meghívjuk a következő függvényt:
<code cpp>
lang_init()
</code>

akkor valójában ez a függvény hajtódik végre:
<code cpp>
c_init()
</code>