C++ Tips med exempel

Du bör se en pekare som en symbolisk representation av en minnesadress. Med pekare kan program simulera call-by-referens. De kan också skapa och manipulera dynamiska datastrukturer. I C++, en pekarvariabel hänvisar till en variabel som pekar på en specifik adress i ett minne som pekas av en annan variabel.

Adresser i C++

Att förstå C++ tips, måste du förstå hur datorer lagrar data.

När du skapar en variabel i din C++ programmet är det tilldelat lite utrymme i datorns minne. Värdet på denna variabel lagras på den tilldelade platsen.

För att veta platsen i datorns minne där data lagras, C++ ger & (referens)operatör. Operatören returnerar adressen som en variabel upptar.

Till exempel, om x är en variabel, returnerar &x adressen till variabeln.

Pointer Declaration Syntax

Förklaringen av C++ tar följande syntax:

datatype *variable_name; 

• Datatypen är bastypen för pekaren som måste vara giltig C++ data typ.
• Variabeln_namn är bör vara namnet på pekarvariabeln.
• Asterisk som används ovan för pekardeklaration liknar den asterisk som används för att utföra multiplikationsoperationer. Det är asterisken som markerar variabeln som en pekare.

Här är ett exempel på giltiga pekardeklarationer i 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

Referensoperator (&) och referensoperator (*)

Referensoperatorn (&) returnerar variabelns adress.

Dereference-operatorn (*) hjälper oss att få värdet som har lagrats i en minnesadress.

Till exempel:

Om vi ​​har en variabel med namnet num, lagrad i adressen 0x234 och lagrar värdet 28.

Referensoperatorn (&) returnerar 0x234.

Referensoperatören (*) kommer att returnera 5.

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

Produktion:

Så här fungerar:

Här är en skärmdump av koden:

Kodförklaring:

1. Importera iostream-huvudfilen. Detta gör att vi kan använda funktionerna som definieras i rubrikfilen utan att få fel.
2. Inkludera std-namnområdet för att använda dess klasser utan att anropa det.
3. Anropa main()-funktionen. Programlogiken bör läggas till i kroppen av denna funktion. { markerar början av funktionens kropp.
4. Deklarera en heltalsvariabel x och tilldela den värdet 27.
5. Deklarera en pekarvariabel *ip.
6. Lagra adressen för variabel x i pekarvariabeln.
7. Skriv ut lite text på konsolen.
8. Skriv ut värdet för variabel x på skärmen.
9. Skriv ut lite text på konsolen.
10. Skriv ut adressen till variabel x. Adressens värde lagrades i variabeln ip.
11. Skriv ut lite text på konsolen.
12. Utskriftsvärdet för lagrat på adressen till pekaren.
13. Programmet bör returnera värde vid framgångsrikt genomförande.
14. Slutet på huvuddelen av funktionen main().

Pekare och matriser

Matriser och pekare fungerar utifrån ett relaterat koncept. Det finns olika saker att notera när man arbetar med arrayer som har pekare. Själva arraynamnet anger arrayens basadress. Det betyder att för att tilldela en arrays adress till en pekare bör du inte använda ett et-tecken (&).

Till exempel:

p = arr;

Ovanstående är korrekt eftersom arr representerar arrayernas adress. Här är ett annat exempel:

p = &arr;

Ovanstående är felaktigt.

Vi kan implicit omvandla en array till en pekare. Till exempel:

int arr [20];
int * ip;

Nedan är en giltig operation:

ip = arr;

Efter ovanstående deklaration kommer ip och arr att vara likvärdiga, och de kommer att dela egenskaper. En annan adress kan dock tilldelas ip, men vi kan inte tilldela något att arr.

Exempel 2:

Det här exemplet visar hur man korsar en array med hjälp av pekare:

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

Produktion:

Här är en skärmdump av koden:

Kodförklaring:

1. Deklarera en heltalspekarvariabel ip.
2. Deklarera en array som heter arr och lagra 6 heltal i den.
3. Tilldela arr till ip. IP och arr blir likvärdiga.
4. Skapa en för en slinga. Slingvariabeln x skapades för att iterera över arrayelementen från index 0 till 5.
5. Skriv ut värdena lagrade på adressen till pekarens IP. Ett värde kommer att returneras per iteration, och totalt 6 repetitioner kommer att göras. Änden är en C++ nyckelord som betyder slutraden. Denna åtgärd låter dig flytta markören till nästa rad efter att varje värde har skrivits ut. Varje värde kommer att skrivas ut på en individuell rad.
6. För att flytta pekaren till nästa int-position efter varje iteration.
7. Slutet av för en slinga.
8. Programmet måste returnera något vid framgångsrikt genomförande.
9. Slutet på huvuddelen () funktion.

NULL-pekare

Om det inte finns någon exakt adress som ska tilldelas, kan pekarvariabeln tilldelas en NULL. Det bör göras under deklarationen. En sådan pekare är känd som en nollpekare. Dess värde är noll och definieras i många standardbibliotek som iostream.

Exempel 3:

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

Produktion:

Här är en skärmdump av koden:

Kodförklaring:

1. Deklarera en pekarvariabel ip och tilldela den värdet NULL.
2. Skriv ut värde för pekarvariabel ip tillsammans med lite text på konsolen.
3. Programmet måste returnera värde efter framgångsrikt slutförande.
4. Slutet på huvuddelen av funktionen main().

Pekare av variabler

Med C++, kan du manipulera data direkt från datorns minne.

Minnesutrymmet kan tilldelas eller omtilldelas som man vill. Detta möjliggörs av Pointer-variabler.

Pekarvariabler pekar på en specifik adress i datorns minne som pekas på av en annan variabel.

Det kan deklareras enligt följande:

int *p;

Eller

int* p;

I exemplet du har vi deklarerat pekarvariabeln p.

Den kommer att hålla en minnesadress.

Asterisken är dereference-operatorn som betyder en pekare till.

Pekaren p pekar på ett heltalsvärde i minnesadressen.

Exempel 4:

#include <iostream>

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

Produktion:

Här är en skärmdump av koden:

Kodförklaring:

1. Deklarera en pekarvariabel p och en variabel x med värdet 30.
2. Tilldela adressen för variabel x till p.
3. Skriv ut värdet på pekarvariabeln p bredvid lite text på konsolen.
4. Programmet måste returnera värde efter framgångsrikt slutförande.
5. Slutet på huvuddelen av funktionen main().

Tillämpning av pekare

Fungerar i C++ kan endast returnera ett värde. Vidare allokeras alla variabler som deklareras i en funktion på funktionsanropsstacken. Så fort funktionen kommer tillbaka förstörs alla stackvariabler.

Argument för att fungera skickas av värde, och alla ändringar som görs på variablerna ändrar inte värdet på de faktiska variablerna som skickas. Följande exempel hjälper till att illustrera detta koncept: -

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

Produktion:

Här är en skärmdump av koden:

Kodförklaring:

1. Skapa en prototyp av en funktion som heter test som tar två heltalsparametrar.
2. Anropa main()-funktionen. Vi kommer att lägga till programlogiken i dess kropp.
3. Deklarera två heltalsvariabler a och b, var och en med värdet 5.
4. Skriv ut lite text på konsolen. Endl (slutraden) flyttar markören för att börja skriva ut på nästa rad.
5. Skriv ut värdet för variabel a på konsolen tillsammans med annan text. Endl (slutraden) flyttar markören för att börja skriva ut på nästa rad.
6. Skriv ut värdet för variabel b på konsolen tillsammans med annan text. Endl (slutraden) flyttar markören för att börja skriva ut på nästa rad.
7. Skapa en funktion som heter test() som tar in adresserna till variabel a och b som parametrar.
8. Skriv ut lite text på konsolen. \n kommer att skapa en ny tom rad innan texten skrivs ut. Endl (slutraden) flyttar markören för att börja skriva ut på nästa rad efter att texten har skrivits ut.
9. Skriv ut värdet för variabel a på konsolen tillsammans med annan text. Endl (slutraden) flyttar markören för att börja skriva ut på nästa rad.
10. Skriv ut värdet för variabel b på konsolen tillsammans med annan text. Endl (slutraden) flyttar markören för att börja skriva ut på nästa rad.
11. Programmet måste returnera värde efter framgångsrikt slutförande.
12. Slutet på huvuddelen av funktionen main().
13. Definierar funktionen test(). Funktionen ska ta två heltalspekarvariabler *n1 och *n2.
14. Tilldela pekarvariabeln *n1 ett värde på 10.
15. Tilldela pekarvariabeln *n2 ett värde på 11.
16. Slutet på kroppen av funktionstestet().

Även om nya värden tilldelas till variabel a och b i funktionstestet, när funktionsanropet är klart, återspeglas inte detsamma i den yttre funktionen huvud.

Att använda pekare som funktionsargument hjälper till att skicka variabelns faktiska adress i funktionen, och alla ändringar som görs på variabeln kommer att återspeglas i den yttre funktionen.

I ovanstående fall har funktionen 'test' adressen till variablerna 'a' och 'b'. Dessa två variabler är direkt åtkomliga från funktionen 'test', och därför återspeglas alla ändringar som görs av dessa variabler i anropsfunktionen 'main'.

Fördelar med att använda Pointers

Här är fördelar/fördelar med att använda Pointers

• Pekare är variabler som lagrar adressen till andra variabler i C++.
• Mer än en variabel kan modifieras och returneras av funktion med hjälp av pekare.
• Minne kan tilldelas och avallokeras dynamiskt med hjälp av pekare.
• Pekare hjälper till att förenkla programmets komplexitet.
• Exekveringshastigheten för ett program förbättras genom att använda pekare.

Sammanfattning

• En pekare hänvisar till en variabelhållaradress för en annan variabel.
• Varje pekare har en giltig datatyp.
• En pekare är en symbolisk representation av en minnesadress.
• Pekare tillåter program att simulera call-by-referens och skapa och manipulera dynamiska datastrukturer.
• arrayer och pekare använder ett relaterat koncept.
• Arraynamnet anger arrayens bas.
• Om du vill tilldela adressen för en array till en pekare, använd inte et-tecken (&).
• Om det inte finns någon specifik adress för att tilldela en pekvariabel, tilldela den en NULL.