C++-aanwijzers met voorbeelden

Wat zijn aanwijzers?

In C++ verwijst een pointer naar een variabele die het adres van een andere variabele bevat. Net als reguliere variabelen hebben pointers een gegevenstype. Een aanwijzer van het type integer kan bijvoorbeeld het adres bevatten van een variabele van het type integer. Een aanwijzer van het tekentype kan het adres bevatten van een variabele van het tekentype.

Je zou een aanwijzer moeten zien als een symbolische weergave van een geheugenadres. Met pointers kunnen programma's call-by-reference simuleren. Ze kunnen ook dynamische datastructuren creëren en manipuleren. In C++ verwijst een pointervariabele naar een variabele die verwijst naar een specifiek adres in een geheugen dat wordt aangeduid door een andere variabele.

In deze C++ tutorial leer je:

Wat zijn aanwijzers?
Adressen in C++
Syntaxis voor aanwijzerdeclaratie
Referentie-operator (&) en Deference-operator (*)
Aanwijzers en arrays
NULL-aanwijzer
Aanwijzers van variabelen
Toepassing van aanwijzers
Voordelen van het gebruik van aanwijzers

Adressen in C++

Om C++-aanwijzers te begrijpen, moet u begrijpen hoe computers gegevens opslaan.

Wanneer u een variabele in uw C++-programma maakt, krijgt deze ruimte in het computergeheugen. De waarde van deze variabele wordt opgeslagen op de toegewezen locatie.

Om de locatie in het computergeheugen te weten waar de gegevens zijn opgeslagen, biedt C++ de & (referentie)operator. De operator retourneert het adres dat een variabele inneemt.

Als x bijvoorbeeld een variabele is, retourneert &x het adres van de variabele.

Syntaxis voor aanwijzerdeclaratie

De declaratie van C++ heeft de volgende syntaxis:

datatype *variable_name;

Het datatype is het basistype van de aanwijzer die een geldig C++-datatype moet zijn.
De variabele_naam is moet de naam zijn van de aanwijzervariabele.
Het sterretje dat hierboven wordt gebruikt voor aanwijzerdeclaratie, is vergelijkbaar met het sterretje dat wordt gebruikt om een vermenigvuldigingsbewerking uit te voeren. Het is de asterisk die de variabele als een aanwijzer markeert.

Hier is een voorbeeld van geldige pointerdeclaraties in 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

Referentie-operator (&) en Deference-operator (*)

De referentie-operator (&) retourneert het adres van de variabele.

De dereferentie-operator (*) helpt ons de waarde te krijgen die is opgeslagen in een geheugenadres.

Bijvoorbeeld:

Als we een variabele hebben met de naam num, opgeslagen in het adres 0x234 en de waarde 28 opslaand.

De referentie-operator (&) retourneert 0x234.

De dereferentie-operator (*) geeft 5 terug.

Voorbeeld 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;
}

Uitvoer:

Hoe dit werkt:

Hier is een screenshot van de code:

Code uitleg:

Importeer het iostream-headerbestand. Hierdoor kunnen we de functies gebruiken die zijn gedefinieerd in het headerbestand zonder fouten te krijgen.
Voeg de std-naamruimte toe om de klassen te gebruiken zonder deze aan te roepen.
Roep de functie main() aan. De programmalogica moet worden toegevoegd aan de hoofdtekst van deze functie. De { markeert het begin van de hoofdtekst van de functie.
Declareer een integer-variabele x en wijs er een waarde van 27 aan toe.
Declareer een pointervariabele *ip.
Sla het adres van variabele x op in de aanwijzervariabele.
Druk wat tekst af op de console.
Druk de waarde van variabele x af op het scherm.
Druk wat tekst af op de console.
Druk het adres van variabele x af. De waarde van het adres werd opgeslagen in de variabele ip.
Druk wat tekst af op de console.
Afdrukwaarde van opgeslagen op het adres van de aanwijzer.
Het programma zou waarde moeten retourneren na succesvolle uitvoering.
Einde van de hoofdtekst van de functie main().

Aanwijzers en arrays

Arrays en pointers werken op basis van een verwant concept. Er zijn verschillende dingen om op te merken bij het werken met arrays met pointers. De arraynaam zelf geeft het basisadres van de array aan. Dit betekent dat u geen ampersand (&) mag gebruiken om het adres van een array aan een pointer toe te wijzen.

Bijvoorbeeld:

p = arr;

Het bovenstaande is correct omdat arr het adres van de arrays vertegenwoordigt. Hier is nog een voorbeeld:

p = &arr;

Het bovenstaande is onjuist.

We kunnen een array impliciet omzetten in een pointer. Bijvoorbeeld:

int arr [20];
int * ip;

Hieronder is een geldige bewerking:

ip = arr;

Na de bovenstaande verklaring zullen ip en arr equivalent zijn en zullen ze eigenschappen delen. Aan ip kan echter een ander adres worden toegewezen, maar aan arr kunnen we niets toekennen.

Voorbeeld 2:

Dit voorbeeld laat zien hoe u een array doorkruist met behulp van pointers:

#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;
}

Uitvoer:

Hier is een screenshot van de code:

Code uitleg:

Declareer een integer pointervariabele ip.
Declareer een array met de naam arr en sla er 6 gehele getallen in op.
Wijs arr toe aan ip. Het ip en arr worden equivalent.
Maak een for a lus. De lusvariabele x is gemaakt om de array-elementen van index 0 tot 5 te herhalen.
Druk de waarden af die zijn opgeslagen op het adres van de pointer-IP. Per iteratie wordt één waarde geretourneerd en er worden in totaal 6 herhalingen uitgevoerd. De endl is een C++-sleutelwoord dat de eindregel betekent. Met deze actie kunt u de cursor naar de volgende regel verplaatsen nadat elke waarde is afgedrukt. Elke waarde wordt op een afzonderlijke regel afgedrukt.
Om de aanwijzer na elke iteratie naar de volgende int-positie te verplaatsen.
Einde van de for a lus.
Het programma moet iets teruggeven bij succesvolle uitvoering.
Einde van de hoofdtekst van de functie ().

NULL-aanwijzer

Als er geen exact adres is dat moet worden toegewezen, kan aan de pointervariabele een NULL worden toegewezen. Dit dient tijdens de aangifte te gebeuren. Zo'n aanwijzer staat bekend als een nulaanwijzer. De waarde is nul en wordt gedefinieerd in veel standaardbibliotheken zoals iostream.

Voorbeeld 3:

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

Uitvoer:

Hier is een screenshot van de code:

Code uitleg:

Declareer een pointervariabele ip en wijs er de waarde NULL aan toe.
Druk de waarde van de aanwijzervariabele ip af naast wat tekst op de console.
Het programma moet waarde retourneren na succesvolle voltooiing.
Einde van de hoofdtekst van de functie main().

Aanwijzers van variabelen

Met C++ kunt u gegevens rechtstreeks vanuit het computergeheugen manipuleren.

De geheugenruimte kan naar wens worden toegewezen of opnieuw worden toegewezen. Dit wordt mogelijk gemaakt door Pointer-variabelen.

Aanwijzervariabelen wijzen naar een specifiek adres in het geheugen van de computer waarnaar wordt verwezen door een andere variabele.

Het kan als volgt worden gedeclareerd:

int *p;

Of,

int* p;

In het you-voorbeeld hebben we de pointervariabele p gedeclareerd.

Het zal een geheugenadres bevatten.

De asterisk is de dereferentie-operator die een verwijzing naar betekent.

De aanwijzer p wijst naar een geheel getal in het geheugenadres.

Voorbeeld 4:

#include <iostream>

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

Uitvoer:

Hier is een screenshot van de code:

Code uitleg:

Declareer een pointervariabele p en een variabele x met een waarde van 30.
Wijs het adres van variabele x toe aan p.
Druk de waarde van de aanwijzervariabele p af naast wat tekst op de console.
Het programma moet waarde retourneren na succesvolle voltooiing.
Einde van de hoofdtekst van de functie main().

Toepassing van aanwijzers

Functies in C++ kunnen slechts één waarde retourneren. Verder worden alle variabelen die in een functie zijn gedeclareerd, toegewezen aan de functieaanroepstack. Zodra de functie terugkeert, worden alle stapelvariabelen vernietigd.

Argumenten om te functioneren worden doorgegeven op waarde, en elke wijziging die op de variabelen wordt aangebracht, verandert de waarde van de daadwerkelijke variabelen die worden doorgegeven niet. Het volgende voorbeeld helpt dit concept te illustreren:-

Voorbeeld 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;
}

Uitvoer:

Hier is een screenshot van de code:

Code uitleg:

Maak een prototype van een functie met de naam test waarvoor twee integer-parameters nodig zijn.
Roep de functie main() aan. We zullen de programmalogica in zijn lichaam toevoegen.
Declareer twee integer-variabelen a en b, elk met een waarde van 5.
Druk wat tekst af op de console. De endl (eindregel) zal de cursor verplaatsen om op de volgende regel te beginnen met afdrukken.
Druk de waarde van variabele a af op de console naast andere tekst. De endl (eindregel) zal de cursor verplaatsen om op de volgende regel te beginnen met afdrukken.
Druk de waarde van variabele b af op de console naast andere tekst. De endl (eindregel) zal de cursor verplaatsen om op de volgende regel te beginnen met afdrukken.
Maak een functie met de naam test() die de adressen van variabele a en b als parameters opneemt.
Druk wat tekst af op de console. De \n maakt een nieuwe lege regel aan voordat de tekst wordt afgedrukt. De endl (eindregel) zal de cursor verplaatsen om te beginnen met afdrukken op de volgende regel nadat de tekst is afgedrukt.
Druk de waarde van variabele a af op de console naast andere tekst. De endl (eindregel) zal de cursor verplaatsen om op de volgende regel te beginnen met afdrukken.
Druk de waarde van variabele b af op de console naast andere tekst. De endl (eindregel) zal de cursor verplaatsen om op de volgende regel te beginnen met afdrukken.
Het programma moet waarde retourneren na succesvolle voltooiing.
Einde van de hoofdtekst van de functie main().
De functie test() definiëren. De functie moet twee integer-pointervariabelen *n1 en *n2 hebben.
De pointervariabele *n1 een waarde van 10 toewijzen.
De pointervariabele *n2 een waarde van 11 toewijzen.
Einde van de hoofdtekst van de functietest().

Hoewel er nieuwe waarden worden toegewezen aan variabele a en b binnen de functietest, wordt hetzelfde niet weerspiegeld in de buitenste functie-hoofd zodra de functieaanroep is voltooid.

Het gebruik van aanwijzers als functieargumenten helpt om het werkelijke adres van de variabele in de functie door te geven, en alle wijzigingen die op de variabele worden uitgevoerd, worden weerspiegeld in de buitenste functie.

In het bovenstaande geval heeft de functie 'test' het adres van de variabelen 'a' en 'b'. Deze twee variabelen zijn direct toegankelijk vanuit de functie 'test', en daarom wordt elke wijziging aan deze variabelen weergegeven in de aanroepfunctie 'hoofd.'

Voordelen van het gebruik van aanwijzers

Dit zijn de voordelen/voordelen van het gebruik van Pointers

Aanwijzers zijn variabelen die het adres van andere variabelen in C++ opslaan.
Meer dan één variabele kan worden gewijzigd en geretourneerd door een functie met behulp van aanwijzers.
Geheugen kan dynamisch worden toegewezen en ongedaan worden gemaakt met behulp van aanwijzers.
Aanwijzingen helpen bij het vereenvoudigen van de complexiteit van het programma.
De uitvoeringssnelheid van een programma verbetert door het gebruik van aanwijzers.

Samenvatting:

Een pointer verwijst naar een variabele die het adres van een andere variabele bevat.
Elke aanwijzer heeft een geldig gegevenstype.
Een aanwijzer is een symbolische weergave van een geheugenadres.
Aanwijzers stellen programma's in staat call-by-reference te simuleren en dynamische datastructuren te creëren en te manipuleren.
Arrays en pointers gebruiken een verwant concept.
De arraynaam geeft de basis van de array aan.
Als je het adres van een array aan een pointer wilt toewijzen, gebruik dan geen ampersand (&).
Als er geen specifiek adres is om een pointervariabele toe te wijzen, wijs er dan een NULL aan toe.

C++ Dynamische toewijzing van arrays met voorbeeld C++ Char-gegevenstype met voorbeelden

C Taal