C/C++: Ha van egy p mutatóm, akkor a p-re hivatkozva a mutató által jelölt memóriaterületen található értékkel, ha pedig *p-re hivatkozok akkor a mutató a "mutatott" memóriacímmel tér vissza ugye?

"p = &x; // A p által mutatott területen lévő értékek értéke egyenértékű lesz a x változó memóriacímével?"

Nem, a p által mutatott terület az x lesz, azaz a p értéke az x címe lesz. A & a címe operátor (többek között).

"*p = *p + x + y; // A *p által visszaadott memóriacím értéke mint balérték - most akkor a p változónak megváltoztatjuk a memóriacímét *p + x + y -re?"

A *p a p álal mutatott memóriaterületet jelenti, nem címet. A * a dereferáló operátor (többek között). Tehát a p által mutatott értéket módosítod, azt a memóriaterületet aminek a címét p tartalmazza.

"C/C++: Ha van egy p mutatóm, akkor a p-re hivatkozva a mutató által jelölt memóriaterületen található értékkel, ha pedig *p-re hivatkozok akkor a mutató a "mutatott" memóriacímmel tér vissza ugye?"

Nem pont fordítva.

"*p = *p + x + y; // A *p által visszaadott memóriacím értéke mint balérték - most akkor a p változónak megváltoztatjuk a memóriacímét *p + x + y -re? "

Nem p által mutatott címen lévő változó (itt ez x változó) értékét növeli x+y azaz 10-el.

p = &x; azt jelenti, hogy *p = x; vagyis p altal mutatott cim x-et tartalmazza.

*p = *p + x + y; pedig egyenerteku x = x + x + y; kifejezessel. A p altal mutatott cim alatt levo erteket (vagyis x-et) modositod, de attol a cim ugyanaz marad, nem "koltozik" mashova a memoriaban.

a program elejen:

p = 002FF72C

*p = 7

a program vegen:

p = 002FF72C

*p = 17

"Tehát maga a mutató arra való hogy az értéke egy memóriacímet tároljon."

Kezdjük az egészet az elejéről. Van ugye a programozásban egy ilyen fogalom, hogy változó. Ez azt jelenti, hogy hogy egy adott memóriacímre megadott névvel hivatkozol.

Továbbá: vannak a változóknak típusai. Van pl. az int típus, ami egy 4 byte-os memóriaterület első byte-jának a címe. A típus itt nyilván meghatározza, hogy az adott címen milyen típusú adat van.

Na most: a mutató az ugyanúgy egy típus, mint az int, vagy a float, vagy bármi más. Neki a típusa egy memória-cím. Továbbá, a kód érthetősége és kezelhetősége érdekében a mutatónak van egy - az érthetőség kedvéért fogalmazzunk így - másodlagos típusa, mégpedig az, hogy a maga a mutató milyen típusú memória-területre mutat. Tehát egy int* változó egy int típusú érték memória-beli címének első byte-jára mutat.

A lényeg: ha egy változóra hivatkozol, akkor mindig a változó által reprezentált memória-címen tárolt értéket kapod vissza.

Tehát: ha hivatkozol egy int változóra, akkor az int értékét kapod meg, amit az a változó reprezentál.

Ha egy int*-ra hivatkozol, akkor a azt az értéket kapod meg, amit az mutató típusú változó reprezentál, ami történetesen maga is egy memória-cím.

Ebből következik, hogy a

p = &x, és a *p = x nem ekvivalens kifejezések.

Nézzük az elsőt:

p = &x;

Azt ugye már leírták korábban, hogy a & operátor az az úgynevezett "címe" operátor, ami bármilyen változónak a címét adja vissza.

Tehát: a p által reprezentált memória-területre(ami egy memória-címet kell hogy tároljon, lévén a p az egy mutató)

beírod az x változó által reprezentált érték CÍMÉT. Magyarul a p az ugyanúgy X-re fog mutatni, mint az X.

Tehát, ebben az esetben a *p = X egyenlőség mindig igaz, akár az X-et változtatod, akár a *p-t.

A második eset viszont:

*p = x;

A * az a dereferencia operátor, azaz: nem a változó által reprezentált címre írsz a memóriában, hanem arra a memória-területre, amire p mutat. Tehát, a p által mutatott címre beírod X értékét.

Ebben az esetben viszont duplikáltad X értékét, tehát *p = X egyenlőség nem mindig igaz.

Ha *p-t módosítod, akkor az X nem fog változni, és fordítva.

Remélem érthető. Sosem tudtam jól magyarázni :D

22:07-es:

A *p = X mar hogyne lenne mindig egyenlo?

----------------------------------

int i=3;

int *j;

j=&i;

printf("i erteke: %d, j erteke: %d\n",i,*j);

*j=5;

printf("i erteke: %d, j erteke: %d\n",i,*j);

----------------------------------

i erteke: 3, j erteke: 3

i erteke: 5, j erteke: 5

Press any key to continue . . .

Elegge durva a magyarazat.

Mutato deklaracio: tipus * nev; pl int *p;

Valtozo deklaracio: tipus nev; pl int x;

int x=10;

A deklaracio soran a valtozonak a fordito kijelol egy cimet, pl 003423FA, es beirja arra a memoriacimre a 10-es integer erteket.

tehat

x cime: 003423FA

x erteke: 10

a & a cime operator, szoval egy valtozo cimet ered el vele

tehat &x az 003423FA lesz.

A mutato egy fokkal tovabbmegy, azaz arra szolgal hogy cimeket taroljunk benne, szoval:

p=&x -> p mutatoba bekerul x valtozo cime, tehat p=003423FA

p most az x-re mutat.

van az indirekcio operator(vagy dereferencia) a *, ami fogja a mutatoban tarolt memoriacimet, es az azon a cimen tarolt erteket adja vissza.

tehat *p az 10, mert p az x-re mutat(cimet tartalmazza) es x erteke pedig 10

tehat

*p === x

p === &x

ha a mutatohoz hozzaadsz 1-et, azaz p=p+1, akkor mar nem x-re fog mutatni, hanem 4 byte-al(int ugye 4 byte hosszu) odebb, amit meg nem tudunk mi.

a p=x is rossz, nagyon rossz, mert akkor a cim az x erteke lesz, azaz 10. ki tudja mi van a 10-es memoriacimen, oprendszer, vedett kod, vagy maga a programod. Ha ezutan a *p=valamivel felulirod azt az adatot ami ottvan akkor crash is lehet a vege :)

Kozben jol rajottem, hogy en sem tudok jol magyarazni :)

De a lenyeg, hogy a valtozo cim(ek)en erteket tarol, a mutato pedig cime(ke)t tarol, es az * indirekcio/dereferencia operatorral ered el a mutatott cimen levo erteket.