Dinamikus tömb példával és magyarázattal?

Sajnos csak Pascal-tudásom van de feltételezem azért, mert nincs megadva neki a méret statikusan, nincs statikusan deklarálva.

Dinamikus tömb esetén egy változóval állíthatod a tömb méretét, hogy mekkorát foglaljon a memóriából, statikus esetén pedig előre megadott tömbméretet használhatsz.

statikus tömb:

int tomb [20];

Dinamikus meg az, amit írtál.

Dinamikus tömböt kétféleképpen tudsz csinálni:

int * p;

int meret ;

// itt valahogy meghatározod a változód értékét, pl beolvasod valahonnan...

//1. változat:

p = malloc ( meret * sizeof (int) ) ;

// használat után itt fel kell szabadítanod a p tömbödet free(p); módon, hogy ne legyen memóriaszivárgás.

//2. változat:

// arra viszont figyelj, hogy ez kizárólag gcc-n működik, mivel egy gcc-s c bővítményről van szó, ami tulajdonképpen stack-en foglal memóriát, nem a heap-en.

// sőt. ezutóbbit ne is használd inkább, csak megemlítettem, hogy ez is létezik.

int tomb2[meret];

Vicces dolog ez. A C-ben (és a C++-ban) igazából nem létezik dinamikus tömb. Viszont, ha úgy vesszük statikus sem. Elmagyarázom :D

Amikor megadsz egy tömböt pl így: int tomb[20]; akkor erre mondjuk, hogy létrehoztál egy statikus 20 hosszú tömböt. Ám ha ezután bemondod neki, hogy tomb[30]=10; akkor arra számítasz, hogy hibát dob, mondván túlindexelted a tömböt. Ez nincs így. A C(++) egyáltalán nem tárolja el a tömb méretét, csupán a tömb változó nem több, mint egy mutató a legelső elemére. De akkor mitől 20 elemű? 20 elemnyi egybefüggő memóriaterületet foglal le neki, viszont magától nem tartja számon a tömb elemszámát (a sizeof() közvetlenül vissza tudja adni a 'bájtokban' foglalt méretet, amit a tömb lefoglal, de ez egy szigorúan fordítási idejű művelet, a nyelvben magában nem tartod számon a tömb hosszát). Mivel a nyelv valójában nem tartja számon a tömb hosszát, így mondhatjuk, hogy a tömb nem is igazán statikus, viszont ha az elemszámán túlmenően indexeled, akkor olyan memóriaterületre hivatkozol, ami nincs külön lefoglalva a tömb számára, és egy csúnya conflictokat okozhat.

Namost, mint mondtam, a statikus tömbök sem igazán staikusak, viszont a dinamikus tömbök sem igazán dinamikusak. A dinamikus tömb C(++) nyelven úgy működik, hogy számontartasz egy pointerváltozót a tömbödhöz, és a pointeren keresztül foglalsz le helyet a tömbödnek. Ettől még ugyanolyan statikus a lefoglalt terület, mint a rendes tömbnél, a különbség annyi, hogy a pointer változódon keresztül bármikor dönthetsz úgy, hogy új terület foglalsz le a tömbödnek. Ez viszont nem a meglévő tömböd dinamikus bővítése, hanem egy új memóriacímen, egy új terület lefoglalása, ami azt jelenti, hogy az addigi statikus tömböd helyett létrehozol egy másik statikus tömböt, és átpakolod bele az értékeket. Tehát a fenti példa igazából nem dinamikus tömböt hoz létre, csak egy trükk arra, hogy könnyebben tudjál új tömböt létrehozni, ha az előző mérete már nem megfelelő.

A C++ tartalmaz beépített 'dianmikus' tárolókat, mint pl az std::vector, amit előszeretettel használnak, merthogy dinamikus. Ám ez a dinamikus típus is ugyanezt a metodikát követi, amit fent leírtam. Ha elfogy a méret, létrehoz egy új tömböt egy másik memóriacímen. Éppezért mikor azt látom, hogy valaki egy üres vectort push_back műveletekkel tölt fel, a hideg borsódzik a hátamon, mert tudom, hogy kb minden push_back során újra kell építenie az addigi tömböt, ami egy elég műveletigényes procedúra lehet a végére. De kívülről csak annyit látsz, hogy "Heh, dinamikus"

Utolsó válaszoló 2016. nov. 8. 10:59

Köszönöm, nekem sokat segítettél! 😀