Tartalomjegyzék

< Cpp

A C++ nyelv

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:

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:

Egyéb fordítók

Szabvány

Amit használunk

Legújabb szabvány

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

Történet

A C++ nyelv kifejlesztője: Bjarne Stroustrup (Dánia)

2003-as szabvány:

É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

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

#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:

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

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

#include <iostream>

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

cout << "karaktersorozat" << endl;

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:

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

Escape szekvenciák

Escape szekvencia Leírás
\' felsővessző (byte 0x27)
\„ idézőjel (byte 0x22)
\\ 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:

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ó

Méret

Példa

unsigned short int szam;

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

long long int szam;

A szam változó 8 bájtos lesz.

long double szam;

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:

maxint.cpp
#include <iostream>
#include <climits>
using namespace std;
 
int main()
{
	cout << INT_MAX << endl;	
	return 0;
}

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:

short a=2000;
int b;
b=a;
class A {};
class B { public: B (A a) {} };
 
A a;
B b=a;

Explicit conversion

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

short a=2000;
int b;
b = (int) a;    // c-stílusú kasztolás
b = int (a);    // függvényszerű jelölés
// 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;
}

Literális állandók

int a = 3;
double b = 4.5;
char c = 'a';
char d = '\n';
string e = "szilva";

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', '\\', '\'', '\"' ÚjSor, visszaperjel, felső vessző, idézőjel
"szöveg\n" Karaktertömbök \0 lezárással
"helló" "világ" Összefűzött karaktersorozatok
true, false logikai állandók 1 és 0
#include <iostream>
using namespace std;
int main()
{
	int a = 0xff; //Hexadecimális szám megadása
	cout << a << endl;	
	return 0;
}

Nevesített állandó

#include <iostream>
using namespace std;
int main()
{
	const int max = 5;
	cout << max << endl;
	return 0;
}
#include <iostream>
#define MAX 25
 using namespace std;
 int main()
{	
	cout << MAX << endl;
	return 0;
}

Formázott kivitel

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

Mezőszélesség

mezo.cpp
#include <iostream>
#include <iomanip>
using namespace std;
 
int main()
{
    int szam = 28;
 
    cout << setw(10) << szam << endl;
 
    return 0;
}

Kitöltés

kitoltes.cpp
#include <iostream>
#include <iomanip>
using namespace std;
 
int main()
{
    double szam = 28.12345;
 
 
    cout << setw(10) << setfill('0') << szam << endl;
 
    return 0;
}

Precizitás

A tizedesek száma lebegőpontos szám esetén:

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;
}

Ha fixpontos ábrázolással szeretnénk ábrázolni:

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;
}

Vezető nullák

vezetonulla.cpp
#include <iostream>
#include <iomanip>
using namespace std;
 
int main()
{
    int szam = 58;
 
    cout << setfill('0') << setw(10) << szam << endl;
 
    return 0;
}

Dátum kiíratása:

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;
}

Számrendszerek

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

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;
}

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):

#include <iostream>
#include <iomanip>
 
int main()
{
    double a;
    a = 328.2843824;
 
    cout.precision(2);
    cout << fixed << a << endl;
 
    return 0;
}
#include <iostream>
#include <iomanip>
 
int main()
{
    double a;
    a = 328.2843824;
 
 
    cout << setprecision(2) << fixed << a << endl;
 
    return 0;
}

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.

p01.cxx
#include <iostream>
#include <cmath>
using namespace std;
int main() {
	cout << abs(-9) << endl;	
	return 0;
}
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.

a = 5;
a = b;
a = 2 + (b = 5);

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

+ összeadás
- kivonás
* szorzás
/ osztás
% maradékképzés
a = 11 % 3;

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.

c++;
c+=1;
c=c+1;

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;
// A tartalma 4, B tartalma 4
B=3;
A=B++;
// 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ő
<= kisebb vagy egyenlő
(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)

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

! operátor

!(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.

&& operátor

a b a && b
true true true
true false false
false true false
false false false

|| operátor

a b a || b
true true true
true false true
false true true
false false false

Példák

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

Feltételes operátor (?)

feltétel ? visszatérési_érték1 : visszatérési_érték2
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

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:

a = (b=3, b+2);

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)
| OR bitenkénti bezáró VAGY (OR)
^ XOR bitenkénti kizáró VAGY (OR)
~ NOT egyes komplemens (bit invertálás)
<< SHL balra tolás
>> SHR jobbra tolás

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

Kasztolás néven ismert típusátalakítás.

int i;
float f = 3.14;
i = (int) f;

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:

a = sizeof (char);

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.

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;
}
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;
}
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;
}

atoi

#include <iostream>
#include <cmath>
 
using namespace std;
 
int main()
{
	char *str = "123";
 
	int a = atoi(str);
 
	cout << a * 2 << endl;
 
	return 0;
}

Bevitel

Egész szám bekérése

int a;
cin >> a;

Karakter bekérése

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

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;
}

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()

mondatbe.cpp
#include <iostream>
 
using namespace std;
 
int main()
{
	cout << "Mondat: ";
	string str;
	getline(cin, str);	
	cout << str << endl;
	return 0;
}

Várakozás egy billentyűnyomásra

cin.get();

Egy billentyűnyomást vár. A lenyomott billentyűt el is tárolhatjuk:

char a = cin.get();

vagy

int a = cin.get();

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.

if (x == 100)
  cout << "x tartalma 100" ;
int a;
cin << a;
 
if(a < 10)
  cout << "Kisebb mint 10" << endl;
else
  cout << "Nagyobb vagy egyenlő mint 10" << endl;
int a;
cin << a;
 
if(a < 10)
{
  cout << "Kisebb mint 10";
  cout << endl;
}
else
{
  cout << "Nagyobb vagy egyenlő mint 10";
  cout << endl;
}

switch

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;
}
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;
}

Iteráció

while

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

for

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

Ha számokat visszafele szeretnénk megkapni, akkor: n--

#include <iostream>
using namespace std;
int main ()
{
  for (int n=10; n>0; n--) {
    cout << n << ", ";
  }
  cout << "TUZ!\n";
  return 0;
}

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.

for ( n=0, i=100 ; n!=i ; n++, i-- )
{
   // amit tenni szeretnénk...
}

do

int i = 1;
 
do
{
    cout << "alma" << endl;
    i++;
}while (i <= 10);

Ugró utasítások

break

#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;
}
10, 9, 8, 7, 6, 5, 4, 3, számlálás leállítása!

continue

// 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;
}
10, 9, 8, 7, 6, 4, 3, 2, 1, TUZ!

goto

// 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;
}
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:

void exit (int exitcode);

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'
int egeszSzamok[5];
 
egeszSzamok[0] = 35;
egeszSzamok[1] = 42;
egeszSzamok[2] = 98;
egeszSzamok[3] = 22;
egeszSzamok[4] = 76;

Kezdőérték:

int egeszSzamok[5] = {35, 42, 98, 22, 76};

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
int matrix[4][7];

Fájlkezelés

Fájlok olvasása, írása

#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;
}

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

#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()
 
}

fájlok olvasása másként

#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()
 
}

fájl nyitás megint

#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;
}

Tagolt olvasás fájlból

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;
}

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:

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

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

class a
{
    (...)
    friend globalisfuggvenyneve(parm. lista);
 
};
 
 
 
class b
{
    (...)
    friend class osztalynev;
 
};

Véletlen szám

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

Szövegkezelés

Szöveg darabolása

#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;
}
#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;
}

Darabolás újra:

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;
	}
}

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ű

Definiálása:

#define BUFFER_SIZE 1024

Használata:

foo = (char *) malloc (BUFFER_SIZE);

Egy tömb megadása:

#define NUMBERS 1, \
                2, \
                3
    int x[] = { NUMBERS };

Olyan mintha ezt írtuk volna:

int x[] = { 1, 2, 3 };

Függvényszerű

#define lang_init()  c_init()

Ezek után, ha meghívjuk a következő függvényt:

lang_init()

akkor valójában ez a függvény hajtódik végre:

c_init()