Hvordan du henvender deg til en peker c++?

Dereferencing er en teknikk for å få data fra en minneadresse som er pekt av en peker mutbar og manipulerer dem. En mutable som holder adressen til en annen mutable er kjent som en peker. (*) -Tegnet vil bli brukt som duereferanseoperatør. Dereferencing En peker oppstår når operatøren (*) blir støpt i pekeren Mutable. Hver gang en peker blir derferert, blir verdien av den mutable representert av pekeren tilbakeført. Derfor vil vi diskutere begrepet dureferanser en peker i C ++ mens vi bruker Ubuntu 20.04 System. La oss ha en ny start med å lage en fil i Ubuntu ved å bruke "Touch" Terminal -kommandoen. Filen vil bli opprettet i maskinens root "Home" -katalog. Det kan åpnes i noen av redaktørene du har i systemet ditt. Vi foretrekker “Nano” -redigereren for å åpne den tomme filen i terminalkonsollen.

$ Touch Dereference.CC
$ nano duereference.CC

Eksempel 01:

Vi må starte med å inkludere et bibliotek “iostream” for bruk av inngangsstrømmen i C++. #Include nøkkelordet brukes til å gjøre det. Deretter kom et standard navneområde “STD” for å la oss bruke standard cout- og cin -uttalelser. Alt arbeidet har blitt utført innen hoved () -metoden. Vi har initialisert en heltallvariabel “n” med verdien 1. En heltallstypepeker “P” brukes til referanse til den variable “N” -adressen via “&” -operatøren. Den første cout -uttalelsen brukes til å vise verdien av variabel “n” på skallet via pekeren “P.”Den neste cout -uttalelsen brukes til å vise verdien av en variabel“ n ”på skallet.

#inkludere
ved hjelp av navneområdet STD;
int main ();
int n = 1;
int* p = & n;
cout<<"Address of n: "<cout<<"Value of n: "<<*p<

Du må samle den nye koden med Ubuntus nyinstallerte G ++ -kompilator for C ++ -språket. Per nå har ingen feil blitt anerkjent. Etter dette har vi utført koden med "./en.ut "-kommandoen og fikk adressen og verdien til variabel“ n ”ved hjelp av pekeren dureferanse.

$ G ++ Dereference.CC
$ ./en.ute

Eksempel 02:

La oss ha et annet eksempel litt annerledes enn eksemplet ovenfor. Så eksemplet er startet med den samme input-output stream bibliotekoverskriften og "STD" standardnavnområdet med "bruk" -nøkkelordet. Nå startes hovedfunksjonen () med erklæringen og initialiseringen av en strengvariabel “V” med strengverdien “Linux.”Etter dette har vi erklært en streng-type peker for å utføre derferencing og relatere den til variabelen“ V ”via“ & ”-operatøren. Dereferencing brukes her for å hente verdien fra en variabel gjennom pekeren. Den eneste endringen er verdien av en variabel, i.e., streng i stedet for et heltall. Den første cout -klausulen brukes til å vise adressen til en variabel "v", og den andre cout -setningen brukes til å vise verdien til variabel "V.”La oss lagre skriptet og utføre koden vår.

#inkludere
ved hjelp av navneområdet STD;
int main ();
streng v = "linux";
streng *p = & v;
cout<<"Address of v: "<cout<<"Value of v: "<<*p<

Koden er samlet. Etter dette har vi utført den enkle koden og fått adressen og verdien av en variabel “V” når.

$ G ++ Dereference.CC
$ ./en.ute

Eksempel 03:

La oss få vår siste, men ikke minst kode startet med bibliotekoverskriften, jeg.e., iostream, og standard navneområdet “STD” igjen. Vi har erklært to heltallvariabler innen hovedfunksjonen (), V1 og V2. Mens V1 initialiseres med verdien “5”. De to første cout -utsagnene viser gjeldende verdier av V1 og V2 på skallet, og den tredje viser pekeren “P” -adresse. Den neste cout -uttalelsen forteller oss at vi skal utføre derferanser nå. Så vi har brukt "P = & V1" -uttalelsen for å tilordne adressen til en variabel V1 til pekeren P. Dette kalles derferencing. Pekeren “P” brukes til å vise adressen og verdien av variabel V1 på skallet via cout -klausulene. Nå tildeler vi verdien av pekeren “P” (som er V1) til variabel v2. COUT -setningen vil vise verdien til V2, og pekeren “P” er tilordnet med en ny verdi på 10. De fire siste utsagnene viser de nye eller nåværende verdiene til V1, V2 og peker “P.”

#inkludere
ved hjelp av navneområdet STD;
int main ();
int v1 = 5, v2;
cout<<"Value of v1: "<cout<<"Value of v2: "<int *p;
cout<<"Value of pointer p: "<cout<<"************* After using p=&v1 ************** "<p =&v1;
cout<<"Address of v1: "<cout<<"Value of v1: "<<*p<v2 =*p;
cout<<"************* After using v2=*p ************** "<cout<<"Address of v2: "<*p = 10;
cout<<"************* After using *p=10 ************** "<cout<<"Address of p: "<cout<<"Value of p: "<<*p<cout<<"Value of v1: "<cout<<"Value of v2: "<

Startverdiene til V1 og V2 er vist sammen med pekeradressen. Etter “P = & V1”, erstattes adressen til “P” med den til V1. Etter “v2 =*p”, er a ”P” referanseverdi tilordnet V2. Ved å bruke “*p = 10” blir verdien av pekeren “P” 10, og på grunn av derferencing blir V1 også 10. Mens V2 og adressen til pekeren er den samme.

$ G ++ Dereference.CC
$ ./en.ute

Konklusjon:

Så dette handlet om hvordan du kan henvise en peker i C++. Vi har brukt dette konseptet for å hente verdiene til en variabel og endre eller oppdatere verdien. Vi håper at vi med hell gir deg enkelt og lettfattelig innhold.