Hogyan használjuk a C ++ mutatókat

A számítógép memóriája a sejtek hosszú sora. Az egyes cellák méretét bájtnak nevezzük. A bájt az a hely, amelyet az ábécé angol karaktere foglal el. A hétköznapi értelemben vett objektum egymást követő bájthalmaz a memóriában. Minden cellának van címe, amely egész szám, általában hexadecimális formában írva. A memóriában lévő objektumok háromféle módon érhetők el. Az objektum az úgynevezett mutató segítségével érhető el. Hozzáférés az úgynevezett referencia segítségével. Azonosító segítségével továbbra is elérhető. A cikk középpontjában a mutatók és a hivatkozások használata áll. A C ++ nyelven van a hegyes és a mutató objektum. A hegyes tárgynak érdekes tárgya van. A mutatóobjektumnak van címe a hegyes objektumhoz.

Alapvető ismeretekkel kell rendelkeznie a C ++ nyelven, beleértve annak azonosítóit, függvényeit és tömbjeit; hogy megértsem ezt a cikket.

A mutató objektumnak és a hegyes objektumnak megvan az azonosítója.

Az üzemeltető címe és

Ez unárikus operátor. Ha azonosító követi, akkor az azonosító objektumának címét adja vissza. Vegye figyelembe a következő nyilatkozatot:

int ptdInt;

Az alábbiakban a kód, a következő kifejezés adja vissza a ptdInt által azonosított címet:

& ptdInt

Kódoláskor nem kell tudni a pontos címet (számot).

Az indirection operátor, *

Ez a mutatók összefüggésében unárikus operátor. Általában egy azonosító előtt gépelik. Ha az azonosító deklarációjában használják, akkor az azonosító az a mutatóobjektum, amely csak a hegyes objektum címét tartalmazza. Ha a mutatóobjektum-azonosító előtt használjuk vissza valamire, akkor a visszaadott dolog a hegyes objektum értéke.

Mutató létrehozása

Vessen egy pillantást a következő kódrészletre:

úszó ptdFloat;
úszó * ptrFloat;
ptrFoat = &ptdFloat;

A szegmens a hegyes objektum, a ptdFloat deklarációjával kezdődik. A ptdFloat egy azonosító, amely csak egy úszó objektumot azonosít. Egy tényleges objektumot (értéket) hozzá lehetett volna rendelni, de ebben az esetben semmit nem rendeltek hozzá. A szegmensben következik a mutató objektum deklarációja. Az azonosító előtti indirection operátor azt jelenti, hogy meg kell tartania egy hegyes objektum címét. Az objektum típusa, amely a utasítás elején lebeg, azt jelenti, hogy a hegyes objektum úszó. A mutatóobjektum mindig ugyanolyan típusú, mint a hegyes objektum. A ptrFoat egy azonosító, amely csak egy mutatóobjektumot azonosít.

A kód utolsó utasításában a hegyes objektum címét hozzárendelik a mutatóobjektumhoz. Vegye figyelembe a address-of operátor használatát &.

A fenti utolsó utasítás (sor) azt mutatja, hogy inicializálás nélkül deklarálta a mutatóobjektumot, nincs szüksége az indirection operátorra, amikor inicializálnia kell. Valójában szintaktikai hiba az indirection operátor használata a harmadik (utolsó) sorban.

A mutatóobjektumot a hegyes objektum deklarálhatja és inicializálhatja egy utasításban, az alábbiak szerint:

úszó ptdFloat;
úszó * ptrFoat = &ptdFloat;

Az előző kódszegmens első sora és ez megegyezik. Az előző kódszegmens második és harmadik sorát itt egy állításba egyesítettük.

A fenti kódban vegye figyelembe, hogy a mutatóobjektum deklarálásakor és inicializálásakor az indirection operátort kell használni. Azonban nem használják, ha az inicializálást később kell elvégezni. A mutatóobjektumot inicializáljuk a hegyes objektum címével.

A következő kódszegmensben az indirection operátort használjuk a hegyes objektum tartalmának visszaadására.

int ptdInt = 5;
int * ptrInt = &ptdInt;
cout << *ptrInt << '\n';

A kimenet 5.

Az itt található utolsó utasításban az indirection operátort használtuk arra, hogy a mutató azonosítójával visszaadjuk a rámutatott értéket. Tehát, ha deklarációban használjuk, az indirection operátor azonosítója megtartja a hegyes objektum címét. Ha egy visszatérési kifejezésben használjuk, a mutató azonosítóval kombinálva, az indirection operátor visszaadja a hegyes objektum értékét.

Nulla hozzárendelése egy mutatóhoz

A mutatóobjektumnak mindig meg kell adnia a hegyes objektum típusát. A mutatóobjektum deklarálásakor a hegyes objektum adattípusát kell használni. A decimális nulla értéke azonban a következő kódszegmenshez hasonlóan hozzárendelhető a mutatóhoz:

int ptdInt = 5;
int * ptrInt;
ptrInt = 0;
vagy a szegmensben,
int ptdInt = 5;
int * ptrInt = 0;

Mindkét esetben a mutatót (azonosítót) null mutatónak hívjuk; jelentése: sehova sem mutat. Vagyis nincs hegyes tárgy címe. Itt 0 decimális nulla, és nem hexadecimális nulla. A hexadecimális nulla a számítógép memóriájának első címére mutat.

Ne próbálja megszerezni azt az értéket, amelyre egy null mutató mutat. Ha megpróbálja, a program lefordíthatja, de nem hajthatja végre.

A tömb neve állandó mutatóként

Vegye figyelembe a következő tömböt:

int arr [] = 000, 100, 200, 300, 400;

Az arr tömb neve valójában az az azonosító, amely rendelkezik a tömb első elemének címével. A következő kifejezés a tömb első értékét adja vissza:

* arr

A tömb, az inkrement operátor, a ++ másképp viselkedik. Az 1 hozzáadása helyett a mutató címét helyettesíti a tömb következő elemének címével. A tömb neve azonban állandó mutató; vagyis tartalma (címe) nem változtatható meg vagy növelhető. Tehát a növekedéshez a tömb kezdőcímét egy nem konstans mutatóhoz kell rendelni az alábbiak szerint:

int * ptr = arr;

Most a ptr növelhető, hogy a tömb következő elemére mutasson. A ptr itt mutató objektumként lett deklarálva. * Itt nélkül nem lenne mutató; azonosító lenne az int objektum megtartása és nem a memóriacím tárolása.

A következő kódszegmens végül a negyedik elemre mutat:

++ptr;
++ptr;
++ptr;

A következő kód adja meg a tömb negyedik értékét:

int arr [] = 000, 100, 200, 300, 400;
int * ptr = arr;
++ptr;
++ptr;
++ptr;
cout << *ptr << '\n';

A kimenet 300.

Funkció neve mint azonosító

A függvény neve a függvény azonosítója. Vegye figyelembe a következő funkciódefiníciót:

int fn ()

cout << "seen" << '\n';
visszatérés 4;

fn a függvény azonosítója. A kifejezés,

& fn

visszaadja a memóriában lévő függvény címét. Az fn olyan, mint a hegyes tárgy. A következő deklaráció egy függvény mutatóját deklarálja:

int (* func) ();

A hegyes objektum azonosítója és a mutató objektum azonosítója különbözik. A func egy függvény mutatója. fn a függvény azonosítója. Tehát a func az alábbiak szerint fn mutatható ki:

func = &fn;

A func értéke (tartalma) az fn címe. A két azonosító összekapcsolható lett volna egy inicializáló utasítással az alábbiak szerint:

int (* func) () = &fn;

Vegye figyelembe a funkciómutatók és a skalármutatók kezelésének különbségeit és hasonlóságait. a func egy függvény mutatója; ez a hegyes tárgy; másképp van deklarálva, mint egy skaláris mutató.

A függvény a,

fn ()
vagy
func ()

Nem hívható meg a * func () paranccsal.

Ha a függvénynek vannak paraméterei, a második zárójelben szerepelnek a paraméterek típusai, és nem kell rendelkeznie a paraméterek azonosítóival. A következő program ezt szemlélteti:

#include
névtér használata std;
float fn (float fl, int in)

visszatér fl;

int main ()

float (* func) (float, int) = &fn;
float val = func (2.5, 6);
cout << val << '\n';
visszatér 0;

A kimenet 2.5.

C ++ Referencia

A C ++ nyelven történő hivatkozás csak egy módszer az azonosító szinonimájának (másik név) előállítására. Használja az & operátort, de nem ugyanúgy, mint a mutatókhoz. Vegye figyelembe a következő kódszegmenst:

int myInt = 8;
int & yourInt = myInt;
cout << myInt << '\n';
cout << yourInt << '\n';

A kimenet:

8
8

Az első utasítás inicializálja a myInt azonosítót; én.e. a myInt deklarálva van, és megtartja az értéket, 8. A második utasítás új azonosítót hoz létre, a yourInt a myInt szinonimája. Ennek elérése érdekében az & operátor az adattípus és az új azonosító közé kerül a deklarációban. A cout állítások azt mutatják, hogy a két azonosító szinonima. Az érték visszaadásához ebben az esetben nem kell megelőznie * . Csak használja az azonosítót.

a myInt és az itteni nem két különböző objektum. Két különböző azonosítóról van szó, amely a memóriában ugyanazon helyet azonosítja (azonosítja), amelynek értéke 8. Ha a myInt értéke megváltozik, akkor a yourInt értéke is automatikusan megváltozik. Ha a yourInt értéke megváltozik, akkor a myInt értéke is automatikusan megváltozik.

A hivatkozások azonos típusúak.

Hivatkozás egy funkcióra

Ahogy hivatkozhat egy skalárra, ugyanúgy hivatkozhat egy függvényre is. A függvényre való hivatkozás kódolása azonban eltér a skalárra való hivatkozás kódolásától. A következő program ezt szemlélteti:

#include
névtér használata std;
float fn (float fl, int in)

visszatér fl;

int main ()

float (& func) (float, int) = fn;
float val = func (2.5, 6);
cout << val << '\n';
visszatér 0;

A kimenet 2.5.

Vegye figyelembe a fő függvény első mondatát, amely a func-ot az fn szinonimája. Mindkettő ugyanarra a funkcióra hivatkozik. Vegye figyelembe a &. Tehát itt a referencia operátor, és nem az operátor címe. A függvény meghívásához használja bármelyik nevet.

A referenciaazonosító nem azonos a mutatóazonosítóval.

A mutató visszaküldése funkció

A következő programban a függvény egy mutatót ad vissza, amely a hegyes objektum címe:

#include
névtér használata std;
float * fn (float fl, int in)

úszó * fll = &fl;
visszatér fll;

int main ()

úszó * val = fn (2.5, 6);
cout << *val << '\n';
visszatér 0;

A kimenet 2.5

Az fn () függvény első állítása csak egy mutatóobjektum létrehozására szolgál. Jegyezze fel az * egyszer használatot és a * pozíciót a funkció aláírásában. Vegye figyelembe azt is, hogy egy másik mutatóobjektum hogyan fogadta a mutatót (címet) a main () függvényben.

Referencia visszaküldés funkció

A következő programban a függvény referenciát ad vissza:

#include
névtér használata std;
float & fn (float fl, int in)

úszó & frr = fl;
visszatér frr;

int main ()

float & val = fn (2.5, 6);
cout << val << '\n';
visszatér 0;

A kimenet 2.5.

Az függvény első állítása, az fn () csak referencia létrehozására szolgál. Jegyezze fel a funkció egyszeres használatát és pozícióját a funkció aláírásában. Vegye figyelembe azt is, hogy egy másik referencia hogyan fogadta a referenciát a main () függvényben.

Mutató átadása egy funkciónak

A következő programban egy mutatót, amely valójában egy úszó hegyes objektum címe, argumentumként küldünk a függvénynek:

#include
névtér használata std;
float fn (float * fl, int in)

visszatér * fl;

int main ()

úszó v = 2.5;
úszó val = fn (& v, 6);
cout << val << '\n';
visszatér 0;

A kimenet 2.5

Jegyezze fel az * úszó paraméter használatát és helyzetét a függvény aláírásában. Amint az fn () függvény kiértékelése megkezdődik, a következő állítás hangzik el:

úszó * fl = & v;

Az fl és a v is ugyanarra a hegyes objektumra mutat, amely 2-et tart.5. * a fl a visszatérési nyilatkozaton nem nyilatkozat; a hegyes objektum értékét jelenti, amelyre a mutató objektum mutat.

Funkció hivatkozásának átadása

A következő programban hivatkozást küldünk argumentumként a függvényre:

#include
névtér használata std;
float fn (float & fl, int in)

visszatér fl;

int main ()

úszó v = 2.5;
úszó val = fn (v, 6);
cout << val << '\n';
visszatér 0;

A kimenet 2.5

A függvény aláírásában vegye figyelembe az & float paraméter használatát és helyzetét. Amint az fn () függvény kiértékelése megkezdődik, a következő állítás hangzik el:

úszó & fl = v;

Tömb átadása egy függvénynek

A következő program bemutatja, hogyan adhatunk át tömböt egy függvénynek:

#include
névtér használata std;
int fn (int arra [])

visszatér arra [2];

int main ()

int arr [] = 000, 100, 200, 300, 400;
int val = fn (arr);
cout << val << '\n';
visszatér 0;

A kimenet 200.

Ebben a programban a tömböt adják át. Vegye figyelembe, hogy az aláírás függvény paramétere üres tömb deklarációval rendelkezik. A függvényhívás argumentuma csak egy létrehozott tömb neve.

Visszaadhat-e egy C ++ függvény tömböt?

A C ++ függvényben lévő függvény visszaadhatja a tömb értékét, de a tömböt nem. A következő program összeállítása hibaüzenetet eredményez:

#include
névtér használata std;
int fn (int arra [])

visszatér arra;

int main ()

int arr [] = 000, 100, 200, 300, 400;
int val = fn (arr);
visszatér 0;

Mutató mutatója

A mutató egy másik mutatóra mutathat. Vagyis egy mutatóobjektumnak lehet egy másik mutatóobjektuma címe. Még mindig ugyanannak a típusnak kell lenniük. A következő kódszegmens ezt szemlélteti:

int ptdInt = 5;
int * ptrInt = &ptdInt;
int ** ptrptrInt = &ptrInt;
cout << **ptrptrInt << '\n';

A kimenet 5.

A pointer-pointer deklarációban a dupla * szerepel. Az utolsó hegyes objektum értékének visszaadásához továbbra is a dupla * értéket használjuk.

Mutatók tömbje

A következő program bemutatja, hogyan kell kódolni egy tömb mutatót:

#include
névtér használata std;
int main ()

int szám0 = 000, szám1 = 100, szám2 = 200, szám3 = 300, szám4 = 400;
int * no0 = & num0, * no1 = & num1, * no2 = & num2, * no3 = & num3, * no4 =&num4;
int * arr [] = nem0, no1, no2, no3, no4;
cout << *arr[4] << '\n';
visszatér 0;

A kimenet:

400

Vegye figyelembe a * használatát és helyét a tömb deklarációjában. Vegye figyelembe a * használatát, ha visszaad egy értéket a tömbben. A mutató mutatóval kettő * vesz részt. Mutatók tömbje esetén egy * -ról már gondoskodtak, mert a tömb azonosítója mutató.

Változó hosszúságú húrok tömbje

A karakterlánc egy konstans, amely mutatót ad vissza. A változó hosszúságú húrok tömbje mutató tömb. A tömb minden értéke mutató. A mutatók a memóriahelyekre vonatkozó címek és azonos méretűek. A különböző hosszúságú húrok máshol vannak a memóriában, nem a tömbben. A következő program szemlélteti a felhasználást:

#include
névtér használata std;
int main ()

const char * arr [] = "nő", "fiú", "lány", "felnőtt";
cout << arr[2] << '\n';
visszatér 0;

A kimenet „lány”.

A tömb deklarációja a konstansra fenntartott, „const” szóval kezdődik; amelyet a karakter „char”, majd a csillag, * jelez, hogy minden elem mutató. A tömbből egy karakterlánc visszaküldéséhez a * nem kerül felhasználásra, az egyes karakterláncok mutatójának implicit jellege miatt. Ha * -t használunk, akkor a karakterlánc első eleme visszatér.

Mutató egy funkcióhoz, amely mutatót ad vissza

A következő program bemutatja, hogyan kódolják a mutatót visszaadó függvény mutatóját:

#include
névtér használata std;
int * fn ()

int szám = 4;
int * inter = #
visszatér inter;

int main ()

int * (* func) () = &fn;
int val = * func ();
cout << val << '\n';
visszatér 0;

A kimenet 4.

Mutató deklarálása egy függvényhez, amely mutatót ad vissza, hasonló a mutató deklarálásához egy közönséges függvényhez, de csillaggal előzi meg. A main () függvény első állítása ezt szemlélteti. A függvény mutatóval történő meghívásához előzze meg a *.

Következtetés

A skalár mutatójának létrehozásához tegyen valami hasonlót,

úszó hegyes;
lebegő * mutató = &pointed;

* két jelentése van: egy deklarációban mutatót jelöl; visszaadni valamit, ez a hegyes tárgy értéke.

A tömb neve állandó mutató a tömb első elemére.

A függvényre mutató mutató létrehozásához megteheti,

int (* func) () = &fn;

ahol az fn () egy máshol definiált függvény, a func pedig a mutató.

& két jelentése van: egy deklarációban hivatkozást (szinonimát) jelöl ugyanarra az objektumra, mint egy másik azonosítót; ha valamit visszaküld, az a címét jelenti.

Ha hivatkozást szeretne létrehozni egy függvényre, megteheti,

float (& refFunc) (float, int) = fn;

ahol az fn () egy máshol definiált függvény, a refFunc pedig a referencia.

Amikor egy függvény visszaad egy mutatót, a visszaküldött értéket egy mutatónak kell fogadnia. Amikor egy függvény visszaad egy referenciát, a visszaküldött értéket referenciának kell fogadnia.

Amikor mutatót ad át egy függvénynek, a paraméter egy deklaráció, míg az argumentum egy hegyes objektum címe. Ha referenciát ad át egy függvénynek, akkor a paraméter egy deklaráció, míg az argumentum a referencia.

Ha egy tömböt átad egy függvénynek, akkor a paraméter egy deklaráció, míg az argumentum a tömb neve [] nélkül. A C ++ függvény nem ad vissza tömböt.

A pointer-pointer szükség esetén kettő * kell egy helyett.

Chrys