Valaki leírná konyhanyelven, hogy mi értelme van a mutatóknak?

Szinntén a memóriában van tárolva, csak más helyen. Azt hogy mire jó pontosan így nehéz elmagyarázni. Kb. PLC-programozásnál használtam először, persze itt alacsonyabb szinten megy a dolog, mert konkrétan kell ismerni a mutató szerkezetét, egy C++-ban nem kell tudnod hogy a mutató melyik bájtja melyik funkcióval bír, amíg a PLC-nél 10 bájtos mutatók is vannak és minden bájtnak meg van a funkciója mint az adattípus leírása stb.

A lényeg hogy ott akkor kell használni, amikor az ember univerzális függvényeket programoz, amikor még nem tudjuk hogy melyik adatblokkból hányadik adat lesz a bemenet illetve kimenet, csak a típusát tudjuk. Amikor elkészült, a konkrét címeket a projektáló illetve üzembehelyező adja meg.

Egy magasabb szintű nyelven mint C++ sokkal több funkciója lehet a pointereknek, lehet csatolt listát csinálni, ezt dinamikusan bővíteni (régen ugye az ansi c-ben malloc függvény volt erre).

Vagy pl. pointerekkel szokták tipikusan a bináris fákat felépíteni, vagy bonyolultbb szerkezeteket.

A legtriviálisabb válasz az, hogy javítja a hatékonyságot, ha például nagy méretű osztályoknál, adatszerkezeteknél nem kell a teljes adatmennyiséget mozgatni a memóriában, csak a mutatókat manipulálni.

Konyhanyelven: ha veszel egy házat, akkor nem hordod át a házat téglánként a saját telkedre, mert az baromi sok munka, csak átírtok egy nevet a tulajdonosi lapon.

Na szóval...

Van a memória. Ez kinek 4GB, kinek 8. Ebbe két dolgot tudunk beletuszkolni:

- adatot

- végrehajtható utasítást

Az első eset közismertebb. Tegyük fel, csinálsz valamit:

int i = 5;

Ezt valahol tárolni kellett. Namármost a memóriát a processzor bájtonként kezeli. Meg tudja nézni, mi van a 0. bájton, mi van az 1. bájton, stb. Pro tip-ként, ha belegondolsz, hogy 32 biten a legnagyobb ábrázolható előjel nélküli pozitív egész szám a 4294967296, ezt szépen 1024-gyel elosztogatva azt kapjuk, hogy egy 32 bites processzor 4GB-nál több memóriát nem tud kezelni. Ezért kell 64 bites rendszer, ha ennél többet akarsz.

Ha létrehoztál valamit a memóriában, akkor a géptől meg tudod kérdezni, hogy a memóriában hányadik bájton kezdődik:

&i;

Az egyértelműség kedvéért ezt a kifejezést nevezzük pointer-típusú kifejezésnek.

Ha ezt te le akarod tárolni, akkor kell egy olyan változó, aminek az értéke pointer lehet.

* cim = &i;

Na de ezzel még van egy gond. Oké, hogy tudjuk, hogy mely címen kezdődik az adat, de ahhoz, hogy ezzel mi dolgozzunk, tudnunk kell, hogy azon a címen milyen típusú adat van. Ez hordozza magában ugyanis azt az információt, hogy a címtől kezdve hány bájtot kell felolvasnunk, hogy visszakapjuk az adatot.

int* cim = &i;

Ha nem tudjuk, hogy azon a memóriacímen milyen típusú adat van, azt a void kulcsszóval jelöljük:

void* cim = &i;

Mivel ez nem hordozza magában azt az információt, hogy hány bájtot kell felolvasni, hogy visszakapjuk az adatot, így nem túl sok mindent tudunk vele kezdeni.

Amúgy a * jel bárhol állhat, például:

int* cim;

int *cim;

int * cim;

A lényeg, hogy mindig csak az a változó lesz pointer, ami előtt áll. Például:

int* cim, a, b, c;

A cim pointer lesz, míg a, b, c int típusú változók.

A végrehajtható utasítások pointerként történő kezeléséről most inkább nem beszélnék.