Hvordan bruke C ++ pekere
Operatørens adresse, og
Dette er en unarisk operatør. Når den blir fulgt av en identifikator, returnerer den adressen til identifikatorens objekt. Tenk på følgende erklæring:
int ptdint;
Nedenfor er koden, følgende uttrykk, vil returnere adressen identifisert av PTDINT:
& ptdint
Du trenger ikke å vite den nøyaktige adressen (nummeret) som kode.
Indireksjonsoperatøren, *
Dette er en unarisk operatør i sammenheng med pekere. Det skrives vanligvis foran en identifikator. Hvis den brukes i en erklæring om identifikatoren, er identifikatoren pekerobjektet som bare inneholder adressen til det spisse objektet. Hvis det brukes foran Pointer -objektidentifikatoren, for å returnere noe, er det som er returnert, verdien av det spisse objektet.
Opprette en peker
Ta en titt på følgende kodesegment:
Float Ptdfloat;
float *ptrfloat;
ptrFoat = &ptdFloat;
Segmentet begynner med erklæringen om det spisse objektet, ptdfloat. Ptdfloat er en identifikator, som bare identifiserer et float -objekt. Et faktisk objekt (verdi) kunne ha blitt tildelt det, men i dette tilfellet har ingenting blitt tildelt det. Neste i segmentet er det erklæringen om pekerobjektet. Indireksjonsoperatøren foran denne identifikatoren betyr at den må holde adressen til et spiss objekt. Objekttypen, flyter i begynnelsen av uttalelsen, betyr at det spisse objektet er en flottør. Pekerobjektet er alltid av samme type som det spisse objektet. PTRFOAT er en identifikator, som bare identifiserer et pekerobjekt.
I den siste uttalelsen av koden blir adressen til det spisse objektet tilordnet pekerobjektet. Legg merke til bruken av operatørens adresse, og.
Den siste uttalelsen (linjen) ovenfor viser at du ikke trenger indireksjonsoperatøren, når du må initialisere det etter å ha erklært pekeren uten initialisering, og når du må initialisere det. Det er faktisk en syntaksfeil å bruke indireksjonsoperatøren i den tredje (siste) linjen.
Pekerobjektet kan deklareres og initialiseres av det spisse objektet i en uttalelse, som følger:
Float Ptdfloat;
float *ptrfoat = &ptdFloat;
Den første linjen i det forrige kodesegmentet og dette, er den samme. Den andre og tredje linjen i det forrige kodesegmentet er blitt kombinert til en uttalelse her.
Legg merke til i koden ovenfor at når du erklærer og initialiserer pekerobjektet, må indireksjonsoperatøren brukes. Det brukes imidlertid ikke hvis initialiseringen skal gjøres etterpå. Pekerobjektet initialiseres med adressen til det spisse objektet.
I følgende kodesegment brukes indireksjonsoperatøren til å returnere innholdet i det spisse objektet.
int ptdint = 5;
int *ptrint = &ptdInt;
cout << *ptrInt << '\n';
Utgangen er 5.
I den siste uttalelsen her har indireksjonsoperatøren blitt brukt til å returnere verdien som ble pekt på, av pekeridentifikatoren. Så når den brukes i en erklæring, ville identifikatoren for indireksjonsoperatøren holde adressen til det spisse objektet. Når den brukes i et returuttrykk, i kombinasjon med pekeridentifikatoren, returnerer indireksjonsoperatøren verdien av det spisse objektet.
Tilordne null til en peker
Pekerobjektet skal alltid ha typen av det spisse objektet. Når du erklærer pekerobjektet, må datatypen til det spisse objektet brukes. Verdien av desimal null kan imidlertid tilordnes til pekeren som i følgende kodesegment:
int ptdint = 5;
int *ptrint;
ptrint = 0;
eller i segmentet,
int ptdint = 5;
int *ptrint = 0;
I begge tilfeller kalles pekeren (identifikatoren) NULL -pekeren; Betydning, det peker på ingensteds. Det vil si at den ikke har adressen til noe spiss objekt. Her er 0 desimal null og ikke heksadesimal null. Heksadesimal null ville peke på den første adressen til dataminnet.
Ikke prøv å få verdien som en nullpeker peker på. Hvis du prøver det, kan programmet kompilere, men kanskje ikke utføres.
Array -navn som en konstant peker
Tenk på følgende matrise:
int arr [] = 000, 100, 200, 300, 400;
Navnet på matrisen, ARR er faktisk identifikatoren som har adressen til det første elementet i matrisen. Følgende uttrykk returnerer den første verdien i matrisen:
*arr
Med matrisen oppfører trinnsoperatøren, ++ seg annerledes. I stedet for å legge til 1, erstatter den adressen til pekeren, med adressen til neste element i matrisen. Navnet på matrisen er imidlertid en konstant peker; Betydning av innholdet (adresse) kan ikke endres eller økes. Så for å øke startadressen til matrisen må tilordnes en ikke-konstant peker som følger:
int *ptr = arr;
Nå kan PTR økes for å peke på neste element i matrisen. PTR er her erklært som et pekerobjekt. Uten * her ville det ikke være en peker; Det ville være en identifikator å holde et Int -objekt og ikke å holde en minneadresse.
Følgende kodesegment peker til slutt på det fjerde elementet:
++PTR;
++PTR;
++PTR;
Følgende kode sender ut den fjerde verdien av matrisen:
int arr [] = 000, 100, 200, 300, 400;
int *ptr = arr;
++PTR;
++PTR;
++PTR;
cout << *ptr << '\n';
Utgangen er 300.
Funksjonsnavn som identifikator
Navnet på en funksjon er identifikatoren til funksjonen. Tenk på følgende funksjonsdefinisjon:
int fn ()
cout << "seen" << '\n';
retur 4;
FN er identifikatoren for funksjonen. Uttrykket,
& fn
Returnerer adressen til funksjonen i minnet. FN er som det spisse objektet. Følgende erklæring erklærer en peker til en funksjon:
int (*func) ();
Identifikatoren for det spisse objektet og identifikatoren for pekerobjektet er forskjellig. func er en peker til en funksjon. FN er identifikatoren for en funksjon. Og slik kan func få til å peke på FN som følger:
func = &fn;
Verdien (innholdet) av func er adressen til fn. De to identifikatorene kunne ha blitt koblet til en initialiseringsuttalelse som følger:
int (*func) () = &fn;
Legg merke til forskjellene og likhetene i håndteringsfunksjonspekere og skalarpekere. Func er en peker til en funksjon; det er det spisse objektet; det er erklært annerledes enn en skalarpeker.
Funksjonen kan kalles med,
fn ()
eller
func ()
Det kan ikke kalles med *func ().
Når funksjonen har parametere, har de andre parentesene parametrene og trenger ikke å ha identifikatorene for parametrene. Følgende program illustrerer dette:
#inkludere
ved hjelp av navneområdet STD;
FLOAT FN (FLOAT FL, INT IN)
return fl;
int main ()
float (*func) (float, int) = &fn;
Float val = func (2.5, 6);
cout << val << '\n';
return 0;
Utgangen er 2.5.
C ++ referanse
Henvisning i C ++ er bare en måte å produsere et synonym (et annet navn) for en identifikator. Den bruker & operatøren, men ikke på samme måte som og brukes til pekere. Tenk på følgende kodesegment:
int myint = 8;
int & yourint = myint;
cout << myInt << '\n';
cout << yourInt << '\n';
Utgangen er:
8
8
Den første uttalelsen initialiserer identifikatoren, Myint; Jeg.e. Myint er erklært og laget for å holde verdien, 8. Den andre uttalelsen gjør en ny identifikator, din int et synonym til Myint. For å oppnå dette plasseres & operatøren mellom datatypen og den nye identifikatoren i erklæringen. COUT -uttalelsene viser at de to identifikatorene er synonymer. For å returnere verdien i dette tilfellet, trenger du ikke gå foran den med * . Bare bruk identifikatoren.
Myint og Yourint her, er ikke to forskjellige objekter. De er to forskjellige identifikatorer som refererer til (identifiserer) samme sted i minnet som har verdien, 8. Hvis verdien av Myint endres, vil verdien av din INT også endres automatisk. Hvis verdien av dinint endres, vil verdien av Myint også endre seg automatisk.
Referanser er av samme type.
Henvisning til en funksjon
Akkurat som du kan ha en henvisning til en skalar, kan du også ha en referanse til en funksjon. Koding av en referanse til en funksjon er imidlertid forskjellig fra å kode en referanse til en skalar. Følgende program illustrerer dette:
#inkludere
ved hjelp av navneområdet STD;
FLOAT FN (FLOAT FL, INT IN)
return fl;
int main ()
float (& func) (float, int) = fn;
Float val = func (2.5, 6);
cout << val << '\n';
return 0;
Utgangen er 2.5.
Legg merke til den første uttalelsen i hovedfunksjonen, som gjør Func til et synonym av FN. Begge refererer til den samme funksjonen. Legg merke til engang og plassering av &. Så og er referanseoperatøren her og ikke operatørens adresse. For å kalle funksjonen, bare bruk begge navnet.
En referanseidentifikator er ikke den samme som en pekeridentifikator.
Funksjon som returnerer en peker
I det følgende programmet returnerer funksjonen en peker, som er adressen til det spisse objektet:
#inkludere
ved hjelp av navneområdet STD;
float *fn (float fl, int i)
float *fll = &fl;
return fll;
int main ()
float *val = fn (2.5, 6);
cout << *val << '\n';
return 0;
Utgangen er 2.5
Den første uttalelsen i funksjonen, fn () er der bare for å lage et pekerobjekt. Legg merke til engangs og plassering av * i funksjonssignaturen. Legg også merke til hvordan pekeren (adressen) ble mottatt i hovedfunksjonen () av et annet pekerobjekt.
Funksjon som returnerer en referanse
I det følgende programmet returnerer funksjonen en referanse:
#inkludere
ved hjelp av navneområdet STD;
Float & Fn (Float fl, int i)
float & frr = fl;
Returner frr;
int main ()
Float & val = fn (2.5, 6);
cout << val << '\n';
return 0;
Utgangen er 2.5.
Den første uttalelsen i funksjonen, fn () er der bare for å lage en referanse. Legg merke til engangsbruk og plassering av og i funksjonssignaturen. Legg også merke til hvordan referansen ble mottatt i Main () -funksjonen med en annen referanse.
Passerer en peker til en funksjon
I det følgende programmet blir en peker, som faktisk er adressen til et float -spiss objekt, sendt som et argument til funksjonen:
#inkludere
ved hjelp av navneområdet STD;
float fn (float *fl, int i)
retur *fl;
int main ()
flyte v = 2.5;
float val = fn (& v, 6);
cout << val << '\n';
return 0;
Utgangen er 2.5
Legg merke til bruken og plasseringen av * for float -parameteren i funksjonssignaturen. Så snart evalueringen av FN () -funksjonen starter, blir følgende uttalelse fremsatt:
float *fl = & v;
Både FL og & V peker på det samme spisse objektet som holder 2.5. *FL ved returerklæringen er ikke en erklæring; Det betyr, verdien av det spisse objektet peker på av pekerobjektet.
Passerer en referanse til en funksjon
I det følgende programmet sendes en referanse som et argument for funksjonen:
#inkludere
ved hjelp av navneområdet STD;
Float Fn (Float & FL, int i)
return fl;
int main ()
flyte v = 2.5;
float val = fn (v, 6);
cout << val << '\n';
return 0;
Utgangen er 2.5
Legg merke til bruken og plasseringen av og for float -parameteren i funksjonssignaturen. Så snart evalueringen av FN () -funksjonen starter, blir følgende uttalelse fremsatt:
float & fl = v;
Sende en matrise til en funksjon
Følgende program viser hvordan du gir en matrise til en funksjon:
#inkludere
ved hjelp av navneområdet STD;
int fn (int arra [])
return arra [2];
int main ()
int arr [] = 000, 100, 200, 300, 400;
int val = fn (arr);
cout << val << '\n';
return 0;
Utgangen er 200.
I dette programmet er det matrisen som er bestått. Merk at parameteren til funksjonssignaturen har en tom matrise -erklæring. Argumentet i funksjonssamtalen er bare navnet på en opprettet matrise.
Kan en C ++ -funksjon returnere en matrise?
En funksjon i C ++ kan returnere verdien av en matrise, men kan ikke returnere matrisen. Sammenretting av følgende program resulterer i en feilmelding:
#inkludere
ved hjelp av navneområdet STD;
int fn (int arra [])
returner Arra;
int main ()
int arr [] = 000, 100, 200, 300, 400;
int val = fn (arr);
return 0;
Pekeren til en peker
En peker kan peke på en annen peker. Det vil si at et pekerobjekt kan ha adressen til et annet pekerobjekt. De må fortsatt alle være av samme type. Følgende kodesegment illustrerer dette:
int ptdint = 5;
int *ptrint = &ptdInt;
int ** ptrptrint = &ptrInt;
cout << **ptrptrInt << '\n';
Utgangen er 5.
I erklæringen om peker-til-peker brukes dobbelt *. For å returnere verdien av det endelige spisse objektet, brukes dobbelt * fortsatt.
Array av pekere
Følgende program viser hvordan du koder en rekke pekere:
#inkludere
ved hjelp av navneområdet STD;
int main ()
int num0 = 000, num1 = 100, num2 = 200, num3 = 300, num4 = 400;
int *NO0 = & num0, *NO1 = & num1, *NO2 = & num2, *NO3 = & NUM3, *NO4 =&num4;
int *arr [] = NO0, NO1, NO2, NO3, NO4;
cout << *arr[4] << '\n';
retur 0;
Utgangen er:
400
Legg merke til bruken og plasseringen av * i erklæringen om matrisen. Legg merke til bruken av * når du returnerer en verdi i matrisen. Med pekere på pekere er to * involvert. Når det.
Array av strenger med variabel lengde
En streng bokstavelig er en konstant som returnerer en peker. En rekke strenger med variabel lengde er en rekke pekere. Hver verdi i matrisen er en peker. Pekere er adresser til minneplasser og har samme størrelse. Strengene i de forskjellige lengdene er andre steder i minnet, ikke i matrisen. Følgende program illustrerer bruken:
#inkludere
ved hjelp av navneområdet STD;
int main ()
const char *arr [] = "kvinne", "gutt", "jente", "voksen";
cout << arr[2] << '\n';
retur 0;
Produksjonen er "jente".
Erklæringen om matrisen begynner med det reserverte ordet, “const” for konstant; etterfulgt av "røye" for karakteren, deretter stjerne, * for å indikere at hvert element er en peker. For å returnere en streng fra matrisen, brukes ikke * på grunn av den implisitte naturen til pekeren til hver streng. Hvis * brukes, vil det første elementet i strengen bli returnert.
Peker til en funksjon som returnerer en peker
Følgende program illustrerer hvordan en peker til en funksjon som returnerer en peker er kodet:
#inkludere
ved hjelp av navneområdet STD;
int *fn ()
int num = 4;
int *inter = #
Returner inter;
int main ()
int *( *func) () = &fn;
int val = *func ();
cout << val << '\n';
retur 0;
Utgangen er 4.
Erklæringen om en peker til en funksjon som returnerer en peker ligner på erklæringen til en peker til en vanlig funksjon, men foran med en stjerne. Den første uttalelsen i Main () -funksjonen illustrerer dette. For å ringe funksjonen ved hjelp av pekeren, kan du gå foran den med *.
Konklusjon
For å lage en peker til en skalar, gjør du noe sånt som,
float spiss;
float *peker = &pointed;
* Har to betydninger: I en erklæring indikerer det en peker; For å returnere noe, er det for verdien av det spisse objektet.
Array -navnet er en konstant peker til det første elementet i matrisen.
For å lage en peker til en funksjon, kan du gjøre,
int (*func) () = &fn;
hvor fn () er en funksjon definert andre steder og func er pekeren.
& har to betydninger: I en erklæring indikerer det en referanse (synonym) til samme objekt som en annen identifikator; Når du returnerer noe, betyr det adressen til.
For å lage en referanse til en funksjon, kan du gjøre,
float (& reffunc) (float, int) = fn;
hvor fn () er en funksjon definert andre steder og reffunc er referansen.
Når en funksjon returnerer en peker, må den returnerte verdien mottas med en peker. Når en funksjon returnerer en referanse, må den returnerte verdien mottas med en referanse.
Når du sender en peker til en funksjon, er parameteren en erklæring, mens argumentet er adressen til et spiss objekt. Når du sender en henvisning til en funksjon, er parameteren en erklæring, mens argumentet er referansen.
Når du sender en matrise til en funksjon, er parameteren en erklæring mens argumentet er array -navnet uten []. C ++ -funksjonen returnerer ikke en matrise.
En peker-til-peker trenger to * i stedet for en, der det er aktuelt.