derivative markets a c++ programozás...

Pénzügyi algoritmusokA C++ programozás alapjai

Pointerek

Tömbök (1. rész)

A memória működésePointerek használata

A memória felépítése

• A memória alapegysége a bájt

• Minden bájtnak van egy címe• A cím egy egész szám

• Általában hexadecimálisan ábrázolva

• A 0x0 cím az üres címet jelöli

• A címtartomány a 0x1-től a maximális címig tart• 32 bites processzoroknál 0x00000001-0xFFFFFFFF

0x022B3A01 0x022B3A02 0x022B3A03 0x022B3A04 0x022B3A05 0x022B3A06

0x15 0xFA 0x3B 0xC8 0x75 0x00

Pointerek

• Mutató (pointer):• Egy memóriacímet tartalmazó változó

• Az adott címen található adat hivatkozására való

• Típusa jelöli a címen található adat típusát• Kivétel: void általános pointer

int * myPointer;

Hivatkozott adat típusa

Pointer típus

Változó neve

Pointerek




int * myPointer;int* myPointer;

Pointerek




int * myPointer;int* myPointer; int *myPointer;

Pointerek




int * myPointer;int* myPointer;

int myData, *myPointer;

int *myPointer;

Hogyan kap értéket egy pointer?

• Az address of operátor (&):• Visszaadja egy változó címét a memóriában

• A kapott pointer típusa megegyezik a változó típusával

• Pl. int *myPointer = &myInt;

• A C nyelvből megamaradt malloc függvénnyel

• A new operátorral

A memóriaterület elosztása

• Az OS a memóriát több részre osztja• Rendszermemória: az OS saját célra használja

• Stack (verem): globális és lokális változók, fv-hívások

• Heap (halom): „szabad” felhasználású memória

• A heap használatát az OS szabályozza• Kérésre lefoglal adott méretű területet

• Kérésre felszabadít egy korábban lefoglalt területet

• A heap-en tárolt adatok pointereken keresztül érhetők el

Rendszermemória Stack Heap

Memóriakezelés a heap-en

• Memóriafoglalás• void *malloc(size_t size) függvénnyel

• A new operátorral:• Lefoglal egy megfelelő méretű memóriaszeletet a megadott

típusnak, majd visszaad egy olyan típusú pointert

• Pl. int *myInt = new int;

• Memória felszabadítása• void free(void *ptr) függvénnyel

• A delete operátorral:• Felszabadít a megadott címen a pointer típusának megfelelő

méretű memóriaterületet

• Pl. delete myInt;

A memóriafoglalás működése

• Az OS nyilvántartja a lefoglalt memóriaterületeket



• Foglaláskor lefoglal egy kért méretű szabad részt• Bejegyzi a lefoglalt memóriaterületek közé

• Visszaadja a rá mutató pointert





• Felszabadításkor kitörli a bejegyzést





• Felszabadításkor kitörli a bejegyzést• A terület egy következő foglaláskor újra használható

„Memóriaszivárgás”

• Lefoglalt memóriát csak a pointer értékének ismeretében lehet felszabadítani

• A pointer értéke elveszhet, ha• Felülírjuk

• Megszűnik az azt tároló változó• Pl. véget ér a függvény, vagy egyéb scope

• A hivatkozott memória többé nem foglalható újra• Ez a memóriaszivárgás (memory leak)

A heap használatának célja

• A lokális változók csak a scope-on belül érhetők el• Pl. egy függvény belsejében

• A globális változók mindenhonnan elérhetők• Emiatt a felelősség nehezen korlátozható

• Köztes megoldásként a változók átadhatók paraméterként• De ez másolást jelent, ráadásul a stack korlátos méretű

• A heap-en tárolt adatok akárhonnan láthatók és módosíthatók a pointer birtokában (és csak így)• A pointer kicsi, nyugodtan másolható

A hivatkozott érték elérése

• Dereferencing:• A hivatkozott területen lévő adat kiolvasása/módosítása

• A „*” operátor használatával lehetséges• Pointer típusokra alkalmazható

• Visszaad egy olyan típusú értéket, amilyen a pointer típusa volt

• Pl. int myInt = *myPointer;

• Pl. *myPointer = 5;

• Pointerek pointerekre• Pointer típus hivatkozhat pointerekre is

• Pl. int **myNestedPointer = &myPointer;

• Ilyenkor az érték kiolvasásához több dereferencing kell• Pl. int myInt = **myNestedPointer;

„Mit ír ki?”

Tömbök (1. rész)Több adat együttes tárolása

Indexelhető adattípusok

• Tömb (array):• Adott típusú elemekből álló adathalmaz, amiben az egyes

elemeket az indexükkel azonosítjuk

• Meghatározó a dimenzió és (dimenziónként) az elemszám

• Listák, vektorok, táblázatok implementálására használható

int myArray[5];

Az elemek típusa

Változó neve

Az elemek száma (konstans!)

Tömbök inicializálása

int myArray[5] = {2, 9, 23, 24, 91};

2 9 23 24 91

int myArray[5] = {2, 9, 23};

2 9 23 0 0

int myArray[5] = {};

0 0 0 0 0

int myArray[] = {2, 9, 23, 24, 91};

2 9 23 24 91

Tömbök címzése

• A tömbök elemeit a tömbön és az indexen keresztül lehet elérni• A címzés 0-tól kezdődik!

• Egy n méretű tömb legnagyobb érvényes indexe n – 1

int foo[5];

foo[2] = 75;

foo[0] = a;

foo[a] = 75;

b = foo[a+2];

foo[foo[a]] = foo[2] + 5;

Túlcímzés

• A tömbök egy összefüggő területen foglalnak helyet• Az index egy eltolás a kezdőcímhez képest

• Túlcímzés:• Ha a létrehozásnál megadottnál nagyobb indexet

próbálunk írni/olvasni

• A következmény nem definiált• Tehát veszélyes!

• Tipp: mindig biztosítsuk, hogy a címzés nem megy túl a tömb határain• Különösen veszélyesek a tömbön iteráló ciklusok

Tömb típusú paraméterek

• Tömbök paraméterként való átadásakor nem szabhatjuk meg a tömb hosszát• Egy ilyen paraméterbe bármilyen hosszú tömb átadható

int Sort(int array[]);

Tömb típusú paraméterek

• Tömbök paraméterként való átadásakor nem szabhatjuk meg a tömb hosszát• Egy ilyen paraméterbe bármilyen hosszú tömb átadható

• Emiatt javasolt átadni a tömb hosszát is

int Sort(int array[], int length);

Köszönöm a figyelmet!

derivative markets a c++ programozás...

Documents