C++ Aanwijzingen met voorbeelden

Je zou een pointer 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 door een andere variabele wordt aangewezen.

Adressen binnen C++

Begrijpen C++ tips, u moet begrijpen hoe computers gegevens opslaan.

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

Om de locatie in het computergeheugen te kennen waar de gegevens zijn opgeslagen, C++ biedt 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 van pointerdeclaratie

de verklaring van C++ heeft de volgende syntaxis:

datatype *variable_name; 

• Het datatype is het basistype van de pointer en moet geldig zijn C++ data type.
• De naam_variabele moet de naam van de pointervariabele zijn.
• Asterisk hierboven gebruikt voor pointer-declaratie is vergelijkbaar met asterisk gebruikt om vermenigvuldigingsbewerking uit te voeren. Het is de asterisk die de variabele markeert als een pointer.

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 referentieoperator (&) retourneert het adres van de variabele.

Met de dereferentie-operator (*) kunnen we de waarde ophalen die in een geheugenadres is opgeslagen.

Bijvoorbeeld:

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

De referentieoperator (&) retourneert 0x234.

De dereferentie-operator (*) retourneert 5.

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

Output:

Hoe dit werkt:

Hier is een screenshot van de code:

Code Verklaring:

1. Importeer het iostream-headerbestand. Hierdoor kunnen we de functies gebruiken die in het headerbestand zijn gedefinieerd zonder fouten te krijgen.
2. Neem de std-naamruimte op om de klassen ervan te gebruiken zonder deze aan te roepen.
3. 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.
4. Declareer een geheel getal variabele x en geef deze de waarde 27.
5. Declareer een pointervariabele *ip.
6. Sla het adres van variabele x op in de pointervariabele.
7. Druk wat tekst af op de console.
8. Druk de waarde van variabele x op het scherm af.
9. Druk wat tekst af op de console.
10. Druk het adres van variabele x af. De waarde van het adres werd opgeslagen in de variabele ip.
11. Druk wat tekst af op de console.
12. Printwaarde van opgeslagen op het adres van de aanwijzer.
13. Het programma zou bij succesvolle uitvoering waarde moeten retourneren.
14. Einde van de hoofdtekst van de functie main().

Aanwijzers en arrays

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

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 impliciet een array omzetten in een pointer. Bijvoorbeeld:

int arr [20];
int * ip;

Hieronder ziet u een geldige bewerking:

ip = arr;

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

Voorbeeld 2:

Dit voorbeeld laat zien hoe u een array kunt doorlopen 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;
}

Output:

Hier is een screenshot van de code:

Code Verklaring:

1. Declareer een integer pointervariabele ip.
2. Declareer een array met de naam arr en sla er 6 gehele getallen in op.
3. Wijs arr toe aan ip. Het ip en arr worden gelijkwaardig.
4. Maak een for-lus. De lusvariabele x is gemaakt om de array-elementen van index 0 tot 5 te herhalen.
5. Druk de waarden af ​​die zijn opgeslagen op het adres van het aanwijzer-IP. Per iteratie wordt één waarde geretourneerd en er worden in totaal zes herhalingen uitgevoerd. Het einde is een C++ trefwoord 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.
6. Om de aanwijzer na elke iteratie naar de volgende int-positie te verplaatsen.
7. Einde van de lus.
8. Het programma moet bij succesvolle uitvoering iets retourneren.
9. Einde van de hoofdtekst van de functie main().

Nul punten

Als er geen exact adres is dat moet worden toegewezen, kan aan de pointervariabele een NULL worden toegewezen. Dit moet tijdens de aangifte gebeuren. Zo'n aanwijzer staat bekend als een nulaanwijzer. De waarde ervan 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;
}

Output:

Hier is een screenshot van de code:

Code Verklaring:

1. Declareer een pointervariabele ip en wijs deze de waarde NULL toe.
2. Druk de waarde van de pointervariabele ip af naast wat tekst op de console.
3. Het programma moet waarde retourneren na succesvolle voltooiing.
4. 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.

Pointervariabelen verwijzen naar een specifiek adres in het computergeheugen waarnaar een andere variabele verwijst.

Het kan als volgt worden verklaard:

int *p;

Of,

int* p;

In het voorbeeld jij hebben we de pointervariabele p gedeclareerd.

Het bevat een geheugenadres.

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

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

Output:

Hier is een screenshot van de code:

Code Verklaring:

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

Toepassing van aanwijzingen

Functies in C++ kan slechts één waarde retourneren. Verder worden alle variabelen die in een functie zijn gedeclareerd, toegewezen op de functieaanroepstack. Zodra de functie retourneert, worden alle stackvariabelen vernietigd.

Argumenten voor functies worden doorgegeven op waarde, en elke wijziging die wordt uitgevoerd op de variabelen verandert de waarde van de werkelijke 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;
}

Output:

Hier is een screenshot van de code:

Code Verklaring:

1. Maak een prototype van een functie met de naam test, waaraan twee gehele parameters moeten voldoen.
2. Roep de functie main() aan. We zullen de programmalogica in de hoofdtekst toevoegen.
3. Declareer twee geheeltallige variabelen a en b, elk met een waarde van 5.
4. Druk wat tekst af op de console. De endl (eindregel) verplaatst de cursor en begint met afdrukken op de volgende regel.
5. Druk de waarde van variabele a af op de console naast andere tekst. De endl (eindregel) verplaatst de cursor en begint met afdrukken op de volgende regel.
6. Druk de waarde van variabele b af op de console naast andere tekst. De endl (eindregel) verplaatst de cursor en begint met afdrukken op de volgende regel.
7. Maak een functie met de naam test() die de adressen van variabele a en b als parameters gebruikt.
8. Druk wat tekst af op de console. De \n creëert een nieuwe lege regel voordat de tekst wordt afgedrukt. De endl (eindregel) verplaatst de cursor en begint met afdrukken op de volgende regel nadat de tekst is afgedrukt.
9. Druk de waarde van variabele a af op de console naast andere tekst. De endl (eindregel) verplaatst de cursor en begint met afdrukken op de volgende regel.
10. Druk de waarde van variabele b af op de console naast andere tekst. De endl (eindregel) verplaatst de cursor en begint met afdrukken op de volgende regel.
11. Het programma moet waarde retourneren na succesvolle voltooiing.
12. Einde van de hoofdtekst van de functie main().
13. De functie test() definiëren. De functie moet twee integer-pointervariabelen *n1 en *n2 bevatten.
14. Wijs de pointervariabele *n1 een waarde van 10 toe.
15. Wijs de pointervariabele *n2 een waarde van 11 toe.
16. Einde van de hoofdtekst van de functie test().

Ook al worden er nieuwe waarden toegewezen aan variabelen a en b binnen de functietest, zodra de functieaanroep is voltooid, wordt hetzelfde niet weerspiegeld in de buitenste functie main.

Het gebruik van pointers 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 rechtstreeks toegankelijk vanuit de functie 'test', en daarom wordt elke wijziging aan deze variabelen weerspiegeld in de aanroepfunctie 'main'.

Voordelen van het gebruik van Pointers

Hier volgen de voor- en voordelen van het gebruik van Pointers

• Pointers zijn variabelen die het adres van anderen opslaan variabelen binnen C++.
• Er kan meer dan één variabele per functie worden gewijzigd en geretourneerd met behulp van pointers.
• Geheugen kan dynamisch worden toegewezen en gede-alloceerd met behulp van pointers.
• Pointers helpen de complexiteit van het programma te vereenvoudigen.
• De uitvoeringssnelheid van een programma verbetert door het gebruik van pointers.

Samenvatting

• Een pointer verwijst naar een variabele die het adres van een andere variabele bevat.
• Elke pointer heeft een geldig gegevenstype.
• Een pointer is een symbolische weergave van een geheugenadres.
• Met pointers kunnen programma's call-by-reference simuleren en dynamische datastructuren creëren en manipuleren.
• arrays en pointers gebruiken een gerelateerd concept.
• De arraynaam geeft de basis van de array aan.
• Als u 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, wijst u deze een NULL toe.