C++ Mutatók példákkal

A mutatót a memóriacím szimbolikus ábrázolásaként kell látnia. A mutatók segítségével a programok hivatkozásonként szimulálhatják a hívást. Dinamikus adatstruktúrákat is létrehozhatnak és kezelhetnek. In C++, a mutatóváltozó egy olyan változóra utal, amely egy adott címre mutat a memóriában, amelyet egy másik változó mutat.

Címek be C++

Megérteni C++ mutatók, meg kell értenie, hogyan tárolják a számítógépek az adatokat.

Amikor létrehoz egy változót a C++ program, akkor hozzá van rendelve egy kis hely a számítógép memóriájában. Ennek a változónak az értéke a hozzárendelt helyen tárolódik.

Az adatok tárolási helyének ismerete a számítógép memóriájában, C++ biztosítja a & (referencia) operátor. Az operátor azt a címet adja vissza, amelyet egy változó elfoglal.

Például, ha x egy változó, akkor az &x a változó címét adja vissza.

Mutató deklaráció szintaxisa

A nyilatkozat C++ a következő szintaxist veszi:

datatype *variable_name; 

• Az adattípus a mutató alaptípusa, amelynek érvényesnek kell lennie C++ adattípus.
• A változó_neve a mutatóváltozó nevének kell lennie.
• A fentiekben a mutató deklarációjához használt csillag hasonló a szorzási művelet végrehajtásához használt csillaghoz. A változót a csillag jelöli mutatóként.

Íme egy példa az érvényes mutató deklarációkra C++:

int    *x;    // a pointer to integer
double *x;    // a pointer to double
float  *x;    // a pointer to float
char   *ch     // a pointer to a character

Referencia operátor (&) és Deference operátor (*)

A referencia operátor (&) a változó címét adja vissza.

A hivatkozási operátor (*) segít a memóriacímben tárolt érték megszerzésében.

Például:

Ha van egy szám nevű változónk, akkor a 0x234 címben tároljuk és a 28 értéket tároljuk.

A referencia operátor (&) 0x234-et ad vissza.

A hivatkozási operátor (*) 5-öt ad vissza.

Példa 1:

#include <iostream>
using namespace std;
int main() {
	int  x = 27;  
	int  *ip;        
	ip = &x;       
	cout << "Value of x is : ";
	cout << x << endl;
	cout << "Value of ip is : ";
	cout << ip<< endl;
	cout << "Value of *ip is : ";
	cout << *ip << endl;
	return 0;
}

output:

Hogyan működik ez:

Itt van egy képernyőkép a kódról:

Code Magyarázat:

1. Importálja az iostream fejlécfájlt. Ez lehetővé teszi számunkra, hogy hiba nélkül használjuk a fejlécfájlban meghatározott függvényeket.
2. Szerelje be az std névteret az osztályok használatához anélkül, hogy meghívná.
3. Hívja meg a main() függvényt. A program logikáját hozzá kell adni a függvény törzséhez. A { a függvény törzsének kezdetét jelöli.
4. Deklaráljunk egy x egész változót, és adjunk hozzá 27 értéket.
5. Mutatóváltozó deklarálása *ip.
6. Tárolja az x változó címét a mutatóváltozóban.
7. Nyomtasson szöveget a konzolra.
8. Nyomtassa ki az x változó értékét a képernyőre.
9. Nyomtasson szöveget a konzolra.
10. Nyomtassa ki az x változó címét. A cím értékét az ip változóban tároltuk.
11. Nyomtasson szöveget a konzolra.
12. A mutató címén tárolt érték nyomtatása.
13. A programnak értéket kell visszaadnia a sikeres végrehajtás után.
14. A main() függvény törzsének vége.

Mutatók és tömbök

A tömbök és mutatók egy kapcsolódó koncepció alapján működnek. Különféle dolgokat kell megjegyezni, amikor mutatókkal rendelkező tömbökkel dolgozik. Maga a tömbnév a tömb alapcímét jelöli. Ez azt jelenti, hogy egy tömb címének mutatóhoz való hozzárendeléséhez ne használjon "és" jelet (&).

Például:

p = arr;

A fentiek helyesek, mivel az arr a tömbök címét jelöli. Íme egy másik példa:

p = &arr;

A fenti téves.

Egy tömböt implicit módon mutatóvá alakíthatunk. Például:

int arr [20];
int * ip;

Az alábbiakban egy érvényes művelet látható:

ip = arr;

A fenti deklaráció után az ip és az arr egyenértékűek lesznek, és megosztják a tulajdonságokat. Az ip-hez azonban más cím is rendelhető, de az arr-hez nem rendelhetünk semmit.

Példa 2:

Ez a példa bemutatja, hogyan lehet bejárni egy tömböt mutatók segítségével:

#include <iostream>
using namespace std;
int main() {
	int *ip;
	int arr[] = { 10, 34, 13, 76, 5, 46 };
	ip = arr;
	for (int x = 0; x < 6; x++) {
		cout << *ip << endl;
		ip++;
	}
	return 0;
}

output:

Itt van egy képernyőkép a kódról:

Code Magyarázat:

1. Deklaráljon egy ip egész mutatóváltozót.
2. Deklaráljunk egy arr nevű tömböt, és tároljunk benne 6 egész számot.
3. Az arr hozzárendelése az ip-hez. Az ip és az arr egyenértékűek lesznek.
4. Hozzon létre egy hurkot. Az x hurokváltozót azért hozták létre, hogy a 0-tól 5-ig terjedő tömbelemek között iteráljon.
5. Nyomtassa ki a mutató IP címén tárolt értékeket. Iterációnként egy érték kerül visszaadásra, és összesen 6 ismétlés történik. A endl egy C++ kulcsszó, amely a végsort jelenti. Ez a művelet lehetővé teszi, hogy a kurzort a következő sorra vigye az egyes értékek kinyomtatása után. Minden érték külön sorba kerül nyomtatásra.
6. A mutató mozgatása a következő int pozícióba minden iteráció után.
7. A for egy hurok vége.
8. Sikeres végrehajtás esetén a programnak vissza kell adnia valamit.
9. A main() függvénytörzs vége.

NULL mutató

Ha nincs pontos cím, amit hozzá kell rendelni, akkor a mutatóváltozóhoz NULL értéket rendelhetünk. Ezt a nyilatkozattétel során kell megtenni. Az ilyen mutatót null mutatónak nevezik. Értéke nulla, és számos szabványos könyvtárban, például az iostreamben van meghatározva.

Példa 3:

#include <iostream>
using namespace std;
int main() {
	int  *ip = NULL;
	cout << "Value of ip is: " << ip;
	return 0;
}

output:

Itt van egy képernyőkép a kódról:

Code Magyarázat:

1. Deklaráljon egy ip mutatóváltozót, és adjon hozzá NULL értéket.
2. Nyomtassa ki az ip mutatóváltozó értékét néhány szöveg mellett a konzolon.
3. A programnak értéket kell visszaadnia a sikeres befejezés után.
4. A main() függvény törzsének vége.

Változómutatók

A C++, közvetlenül a számítógép memóriájából kezelheti az adatokat.

A memóriaterület tetszés szerint hozzárendelhető vagy újra hozzárendelhető. Ezt a mutatóváltozók teszik lehetővé.

A mutatóváltozók egy adott címre mutatnak a számítógép memóriájában, amelyre egy másik változó mutat.

A következőképpen deklarálható:

int *p;

Vagy

int* p;

A you példában deklaráltuk a p mutatóváltozót.

Egy memóriacímet fog tárolni.

A csillag a hivatkozás megszüntetésének operátora, amely egy mutatót jelent.

A p mutató egy egész számra mutat a memóriacímben.

Példa 4:

#include <iostream>

using namespace std;
int main() {
	int *p, x = 30;
	p = &x;
	cout << "Value of x is: " << *p;
	return 0;
}

output:

Itt van egy képernyőkép a kódról:

Code Magyarázat:

1. Deklaráljunk egy p mutatóváltozót és egy x változót, amelynek értéke 30.
2. Rendelje hozzá az x változó címét a p-hez.
3. Nyomtassa ki a p mutatóváltozó értékét néhány szöveg mellé a konzolon.
4. A programnak értéket kell visszaadnia a sikeres befejezés után.
5. A main() függvény törzsének vége.

Mutatók alkalmazása

Funkciók be C++ csak egy értéket adhat vissza. Ezenkívül a függvényben deklarált összes változó a függvényhívási veremben van lefoglalva. Amint a függvény visszatér, az összes veremváltozó megsemmisül.

A függvény argumentumait érték adja át, és a változókon végrehajtott módosítások nem változtatják meg a ténylegesen átadott változók értékét. A következő példa segít illusztrálni ezt a koncepciót: -

Példa 5:

#include <iostream>

using namespace std;
void test(int*, int*);
int main() {
	int a = 5, b = 5;
	cout << "Before changing:" << endl;
	cout << "a = " << a << endl;
	cout << "b = " << b << endl;

	test(&a, &b);

	cout << "\nAfter changing" << endl;
	cout << "a = " << a << endl;
	cout << "b = " << b << endl;
	return 0;
}

void test(int* n1, int* n2) {
	*n1 = 10;
	*n2 = 11;
}

output:

Itt van egy képernyőkép a kódról:

Code Magyarázat:

1. Hozzon létre egy teszt nevű függvény prototípusát, amely két egész paramétert vesz fel.
2. Hívja meg a main() függvényt. Hozzáadjuk a program logikáját a törzséhez.
3. Deklaráljunk két a és b egész változót, amelyek mindegyikének értéke 5.
4. Nyomtasson szöveget a konzolra. Az endl (végsor) mozgatja a kurzort a következő sorban történő nyomtatás megkezdéséhez.
5. Nyomtassa ki az a változó értékét a konzolon a többi szöveg mellé. Az endl (végsor) mozgatja a kurzort a következő sorban történő nyomtatás megkezdéséhez.
6. Nyomtassa ki a b változó értékét a konzolon a többi szöveg mellé. Az endl (végsor) mozgatja a kurzort a következő sorban történő nyomtatás megkezdéséhez.
7. Hozzon létre egy test() nevű függvényt, amely paraméterként veszi az a és b változó címét.
8. Nyomtasson szöveget a konzolra. A \n új üres sort hoz létre a szöveg nyomtatása előtt. Az endl (végsor) mozgatja a kurzort, hogy a következő sorban kezdje el a nyomtatást a szöveg kinyomtatása után.
9. Nyomtassa ki az a változó értékét a konzolon a többi szöveg mellé. Az endl (végsor) mozgatja a kurzort a következő sorban történő nyomtatás megkezdéséhez.
10. Nyomtassa ki a b változó értékét a konzolon a többi szöveg mellé. Az endl (végsor) mozgatja a kurzort a következő sorban történő nyomtatás megkezdéséhez.
11. A programnak értéket kell visszaadnia a sikeres befejezés után.
12. A main() függvény törzsének vége.
13. A teszt() függvény meghatározása. A függvénynek két egész számú mutatóváltozót kell felvennie: *n1 és *n2.
14. A *n1 mutatóváltozóhoz 10 értéket rendelünk.
15. A *n2 mutatóváltozóhoz 11 értéket rendelünk.
16. A függvényteszt() törzsének vége.

Annak ellenére, hogy a függvényteszten belül új értékeket rendelnek az a és b változókhoz, a függvényhívás befejeztével ugyanez nem tükröződik a külső fő függvényben.

A mutatók függvényargumentumként való használata segít átadni a változó tényleges címét a függvényben, és a változón végrehajtott összes változás tükröződik a külső függvényben.

A fenti esetben a 'test' függvénynek az 'a' és 'b' változók címe van. Ez a két változó közvetlenül elérhető a 'teszt' függvényből, így az ezeken a változókon végzett bármilyen változtatás a 'main' hívó függvényben is megjelenik.

A mutatók használatának előnyei

Itt vannak a mutatók használatának előnyei/előnyei

• A mutatók olyan változók, amelyek más címét tárolják változók be C++.
• Egynél több változó módosítható és visszaadható a függvény segítségével mutatók segítségével.
• A memória dinamikusan lefoglalható és eltávolítható mutatók segítségével.
• A mutatók segítenek leegyszerűsíteni a program összetettségét.
• A program végrehajtási sebessége javul a mutatók használatával.

GYIK