Definíció: változó, alprogram vagy osztály létrehozása, megvalósítása
struct T; // T osztályt előre deklaráljuk
struct S { T* t; };
struct T { S* s; };
bool ptlan(int i);
bool ps(int i) {
return (i == 0) ? true : ptlan(i-1); }
bool ptlan(int i) {
return (i == 0) ? false : ps(i-1); }
extern: más fordítási egységben definiált objektum deklarációja
extern "C": összeszerkesztés más programnyelven írt tárgykóddal"C" az összeszerkesztés szabályára utala programkód azon pontjai, amelyekhez érkezve garantált, hogy a megelőző kifejezések kiértékelése befejeződött
a kódban előforduló két szekvenciapont között minden objektum legfeljebb egyszer kaphat új értéket
++ operátor használataj = i++ + i++;
k = f(v[i], i++);
m = m++;
n = f() + g();
// ahol f és g közös globális változót használnak
Összetett kifejezések kiértékelése
Értékadás: = operátor
2 * (i = 7) + 3
==)if (i = 3) { ... } // ez rossz, mindig igaz, és i megváltozik
if (3 == i) { ... } // ilyen sorrendben nem lehet elrontani
Értékadás: = operátor
2 * (i = 7) + 3 // értéke 17
További értékadó operátorok: +=, *= stb.
x += y; ⇔ x = x + y;
Vessző operátor
(1, 2, 3) + (4, 5, 6)
(1, 2, 3) + (0, 6)
// mindkét kifejezés értéke 9
f(1, 2, 3)
// három paraméterrel rendelkező függvény
Vessző operátor
t[1,2,3] // t[3]
(i = 46, ++i) + (j = 15, --j)
// i értéke 47 lesz
// j értéke 14 lesz
// a kifejezés értéke 61 lesz
Feltételes kifejezés operátor
(6 == 1) ? (2 << 5) : (128 % 3)
// a feltétel hamis, ezért a kifejezés értéke 2
true ? (2 << 5) : (128 % 3)
// a feltétel igaz, ezért a kifejezés értéke 64
Feltételes kifejezés operátor
false ? 4.0 : "a"
// 4.0 típusa double
// "a" típusa const char*
// fordítási hiba: nem kompatibilisek
Feltételes kifejezés operátor
true ? 'a' : 5
// 'a' típusa char, 5 típusa int
// kompatibilisek:
// char ↦ int automatikus konverzió
// a teljes kifejezés típusa int
// a feltétel igaz, ezért a kifejezés értéke 97
// 'a' ASCII kódja 97
Rövidzáras (lusta kiértékelésű) logikai operátorok: ||, &&
true || x == true
false && x == false
x != 0 && 100 / x < 4
// nullával való osztás elkerülése
p && *p == 1
// nullmutató nem oldható fel
Konstruktorok
T(e)
(int)15.7
int i = 1;
int i = int(1);
int i(1);
Explicit lefoglalás és felszabadítás (allokáció és deallokáció)
new operátorT*, ha T típusú értéket foglaltunk leint* pi = new int;
int* pi = new int(215);
new[] operátorT* visszatérési értékűint* pi = new int[32];
delete és delete[] operátorint* pi = new int;
int* pi2 = new int[32];
// ...
delete pi;
delete[] pi2;
Fixitás: az operandusokhoz képest hol helyezkedik el az operátor szimbóluma?
++i // prefix ++
i++ // posztfix ++
1 * 2 // infix *
true ? 1 : 2 // mixfix ?:
Precedencia: zárójelezési ("kötési") szabályok
1 + 2 * 3 ⇔ 1 + (2 * 3)
Asszociativitás: azonos precedenciájú operátorok kötésének meghatározására
= operátor, egyoperandusú operátorok: jobbról balra kötneka = b = c ⇔ a = (b = c)
*p++ ⇔ *(p++)
a + b - c ⇔ (a + b) - c
Asszociativitás: azonos precedenciájú operátorok kötésének meghatározására
std::cout << 1 << 4 << std::endl;
// kimenet: 14
std::cout << (1 << 4) << std::endl;
// kimenet: 16
Deklaráció: egy vagy több név bevezetése
...
// itt nincsen szükség i változóra
int i;
// innentől használható
{
int i;
{
double d;
{
char c;
}
}
}
for ciklus szintaxisában is pontosvessző vanfor (;;) ;
// végtelen ciklus
// csak az utolsó pontosvessző
// tartozik utasításhoz
if (i == 0) j = 4;
if (i == 0)
{
j = 4;
}
if (i == 0); // üres utasítás
{
j = 4; // ez a blokk mindig lefut
}
if (felt) {
// K&R
}
if (felt)
{
// ANSI C++
}
if (felt)
{
// GNU
}
if (3 == i) ...
if (i = 3) ...
if (p) // ha p nem nullmutató...
{
*p = 3; // ... akkor feloldható
}
int j;
if (i < 3) {
j = 5; // igaz ág
} else {
j = 10; // hamis ág
}
?: operátort használniint j = (i < 3) ? 5 : 10;
endif), ha az elágazás igaz ága is elágazást tartalmaz, nem egyértelmű, hová tartozik a hamis ágif (i == 3) if (i == 3)
if (j == 4) if (j == 4)
k = 1; k = 1;
else else
k = 2; k = 2;
if-hez tartozik a hamis ágif (i < 3) { if (i < 3) {
k = 1; k = 1;
} else if (j > 7) { } else {
k = 2; if (j > 7) {
} else { k = 2;
k = 3; } else {
} k = 3;
}
}
if (i < 3) {
k = 1;
}
if ( !(i < 3) && j > 7 ) {
k = 2;
}
if ( !(i < 3) && !(j > 7) ) {
k = 3;
}
int vagy charswitch után folytatódikint i;
switch (i) { case 1: f1();
break;
case 2: f2();
break;
default: f_def();
}
break utasítás kerülcase 2-ről case 3-ra)switch (i) {
case 1:
f1();
break;
case 2:
case 3:
f2_3();
break;
default:
f4();
}
while (i > 0) {
--i;
cout << i << endl;
}
while (true) {
// végtelen sokszor lefutó kódrészlet
}
break utasítás kilép a ciklusból (a switch utasításhoz hasonlóan)while (true) {
...
if (lepjunk_ki()) break;
...
}
char c;
cin >> c;
while (!cin.eof()) { // itt cin.good() is állhatna
// ciklusmag
cin >> c;
}
cin állapota konvertálódik logikai értékrechar c;
while (cin >> c) {
// ciklusmag
}
do {
// ciklusmag
} while (feltétel);
// ciklusmag
while (feltétel) {
// ciklusmag
}
for (inicializálás; feltétel; számlálás) utasítás
for (int i = 0; i < 10; ++i) j += i;
// inicializálás
while (feltétel) {
// ciklusmag
// számláló léptetése
}
for ciklust használják végtelen ciklus létrehozásárafor (;;) {
// végtelenített ciklusmag
}
breakswitch-ből vagy ciklusbólreturn: függvényekből visszatéréshezswitch, ciklus belsejében is használhatógoto