Kako uporabljati kazalce C ++

Spomin računalnika je dolga vrsta celic. Velikost vsake celice se imenuje bajt. Bajt je prostor, ki ga zaseda angleški znak abecede. Predmet v običajnem pomenu je zaporedni niz bajtov v spominu. Vsaka celica ima naslov, ki je celo število, običajno zapisano v šestnajstiški obliki. Obstajajo trije načini dostopa do predmeta v spominu. Do predmeta lahko dostopate s tako imenovanim kazalcem. Do njega je mogoče dostopati z uporabo tistega, kar je znano kot referenca. Do njega je še vedno mogoče dostopati z identifikatorjem. Poudarek tega članka je na uporabi kazalcev in referenc. V jeziku C ++ sta koničast objekt in kazalec. Koničasti predmet ima predmet zanimanja. Kazalec ima naslov koničastega predmeta.

Imeti morate osnovno znanje jezika C ++, vključno z njegovimi identifikatorji, funkcijami in nizi; razumeti ta članek.

Kazalec in koničast objekt imata svoj identifikator.

Naslov operaterja in

To je unarni operater. Ko mu sledi identifikator, vrne naslov predmeta identifikatorja. Upoštevajte naslednjo izjavo:

int ptdInt;

Spodaj je koda, naslednji izraz bo vrnil naslov, ki ga je določil ptdInt:

& ptdInt

Med kodiranjem vam ni treba vedeti natančnega naslova (številke).

Posredni operater, *

To je unarni operator v kontekstu kazalcev. Običajno se vnese pred identifikator. Če se uporablja v deklaraciji identifikatorja, je identifikator predmet kazalca, ki vsebuje samo naslov usmerjenega predmeta. Če je uporabljen pred identifikatorjem kazalnega predmeta, da nekaj vrne, je vrnjena stvar vrednost usmerjenega predmeta.

Ustvarjanje kazalca

Oglejte si naslednji kodni segment:

float ptdFloat;
float * ptrFloat;
ptrFoat = &ptdFloat;

Segment se začne z izjavo koničastega predmeta, ptdFloat. ptdFloat je identifikator, ki samo identificira plavajoči objekt. Lahko bi mu bil dodeljen dejanski objekt (vrednost), vendar mu v tem primeru ni bilo dodeljeno nič. Naslednja v segmentu je izjava predmeta kazalca. Posrednik operatorja pred tem identifikatorjem pomeni, da mora imeti naslov koničastega predmeta. Tip predmeta, float na začetku stavka, pomeni, da je koničast objekt float. Kazalec je vedno iste vrste kot koničast objekt. ptrFoat je identifikator, ki samo identificira kazalec.

V zadnjem stavku kode je predmet kazalca dodeljen naslovu usmerjenega predmeta. Upoštevajte uporabo naslova operaterja in.

Zadnja izjava (vrstica) zgoraj kaže, da po razglasitvi kazalnega objekta brez inicializacije ne potrebujete posrednika, ko ga morate inicializirati. Dejansko gre za sintaksno napako, če uporabimo posrednik v tretji (zadnji) vrstici.

Kazalec lahko deklarira in inicializira koničasti objekt v enem stavku, in sicer:

float ptdFloat;
float * ptrFoat = &ptdFloat;

Prva vrstica prejšnjega in tega odseka kode sta enaki. Druga in tretja vrstica prejšnjega segmenta kode so bile tukaj združene v en stavek.

V zgornji kodi upoštevajte, da je treba pri deklariranju in inicializaciji kazalnega objekta uporabiti posrednik. Vendar se ne uporablja, če naj se inicializacija izvede pozneje. Kazalec se inicializira z naslovom koničastega predmeta.

V naslednjem segmentu kode se posrednik uporablja za vrnitev vsebine koničastega predmeta.

int ptdInt = 5;
int * ptrInt = &ptdInt;
cout << *ptrInt << '\n';

Izhod je 5.

V zadnjem stavku tukaj je bil posrednik posrednika uporabljen za vrnitev vrednosti, na katero je kazal identifikator kazalca. Torej, kadar se uporablja v izjavi, bi identifikator posrednika imel naslov usmerjenega predmeta. Ko se uporablja v povratnem izrazu, v kombinaciji z identifikatorjem kazalca posrednik vrne vrednost usmerjenega predmeta.

Dodelitev ničle kazalcu

Kazalec mora vedno imeti vrsto koničastega predmeta. Pri razglasitvi kazalnega predmeta je treba uporabiti podatkovni tip usmerjenega predmeta. Kazalcu pa lahko dodelimo vrednost decimalne ničle, kot v naslednjem segmentu kode:

int ptdInt = 5;
int * ptrInt;
ptrInt = 0;
ali v segmentu,
int ptdInt = 5;
int * ptrInt = 0;

V obeh primerih se kazalec (identifikator) imenuje ničelni kazalec; kar pomeni, da ne kaže nikamor. To pomeni, da nima naslova nobenega koničastega predmeta. Tu je 0 decimalna nič in ne šestnajstiška nič. Šestnajstiška ničla bi kazala na prvi naslov računalniškega pomnilnika.

Ne poskušajte pridobiti vrednosti, na katero kaže ničelni kazalec. Če poskusite s tem, se program morda prevede, vendar se ne bo izvedel.

Ime polja kot stalni kazalec

Upoštevajte naslednjo matriko:

int arr [] = 000, 100, 200, 300, 400;

Ime polja arr je pravzaprav identifikator, ki ima naslov prvega elementa polja. Naslednji izraz vrne prvo vrednost v matriki:

* arr

Z matriko, operatorjem prirastka, ++ se obnaša drugače. Namesto da doda 1, nadomesti naslov kazalca z naslovom naslednjega elementa v matriki. Vendar je ime matrice konstanten kazalec; kar pomeni, da njegove vsebine (naslova) ni mogoče spremeniti ali povečati. Torej, za povečanje je treba začetni naslov matrike dodeliti nestalnemu kazalcu, kot sledi:

int * ptr = arr;

Zdaj lahko ptr povečamo tako, da kaže na naslednji element polja. ptr je bil tukaj razglašen za kazalec. Brez * tukaj ne bi šlo za kazalec; to bi bil identifikator za objekt int in ne za naslov pomnilnika.

Naslednji segment kode končno kaže na četrti element:

++ptr;
++ptr;
++ptr;

Naslednja koda izpiše četrto vrednost polja:

int arr [] = 000, 100, 200, 300, 400;
int * ptr = arr;
++ptr;
++ptr;
++ptr;
cout << *ptr << '\n';

Izhod je 300.

Ime funkcije kot identifikator

Ime funkcije je identifikator funkcije. Upoštevajte naslednjo definicijo funkcije:

int fn ()

cout << "seen" << '\n';
povratek 4;

fn je identifikator funkcije. Izraz,

& fn

vrne naslov funkcije v pomnilnik. fn je kot koničast predmet. Naslednja izjava razglasi kazalec na funkcijo:

int (* func) ();

Identifikator za usmerjeni objekt in identifikator za kazalec se razlikujeta. func je kazalec na funkcijo. fn je identifikator funkcije. Tako lahko funkc usmerimo tako, da kaže na fn na naslednji način:

func = &fn;

Vrednost (vsebina) func je naslov fn. Oba identifikatorja bi bila lahko povezana z izjavo o inicializaciji, kot sledi:

int (* func) () = &fn;

Upoštevajte razlike in podobnosti pri ravnanju s kazalci funkcij in skalarnimi kazalci. func je kazalec na funkcijo; je koničasti predmet; razglašen je drugače kot skalarni kazalec.

Funkcijo lahko pokličete s,

fn ()
ali
func ()

Ni ga mogoče poklicati z * func ().

Ko ima funkcija parametre, imajo drugi oklepaji tipe parametrov in jim ni treba imeti identifikatorjev za parametre. Naslednji program to ponazarja:

#include
uporaba imenskega prostora std;
float fn (float fl, int in)

vrnitev fl;

int main ()

float (* func) (float, int) = &fn;
float val = func (2.5, 6);
cout << val << '\n';
vrnitev 0;

Izhod je 2.5.

Referenca C ++

Sklicevanje v jeziku C ++ je le način za izdelavo sopomenke (drugega imena) za identifikator. Uporablja operator &, vendar ne na enak način kot & se uporablja za kazalce. Upoštevajte naslednji segment kode:

int myInt = 8;
int & yourInt = myInt;
cout << myInt << '\n';
cout << yourInt << '\n';

Rezultat je:

8
8

Prvi stavek inicializira identifikator, myInt; jaz.e. myInt je razglašen in zadržan za vrednost, 8. Drugi stavek naredi nov identifikator, yourInt sinonim za myInt. Da bi to dosegli, se operater & postavi med vrsto podatkov in nov identifikator v izjavi. Izjave cout kažejo, da sta identifikatorja sinonima. Če želite vrniti vrednost v tem primeru, vam ni treba pred * . Samo uporabite identifikator.

myInt in yourInt tukaj, nista dva različna predmeta. Gre za dva različna identifikatorja, ki se sklicujeta (identificirata) isto lokacijo v pomnilniku z vrednostjo, 8. Če se spremeni vrednost myInt, se bo samodejno spremenila tudi vrednost yourInt. Če spremenite vrednost yourInt, se bo samodejno spremenila tudi vrednost myInt.

Reference so iste vrste.

Sklic na funkcijo

Tako kot se lahko sklicujete na skalarja, se lahko sklicujete tudi na funkcijo. Vendar se kodiranje sklica na funkcijo razlikuje od kodiranja sklica na skalar. Naslednji program to ponazarja:

#include
uporaba imenskega prostora std;
float fn (float fl, int in)

vrnitev fl;

int main ()

float (& func) (float, int) = fn;
float val = func (2.5, 6);
cout << val << '\n';
vrnitev 0;

Izhod je 2.5.

Upoštevajte prvi stavek v glavni funkciji, zaradi česar je func sinonim fn. Oba se sklicujeta na isto funkcijo. Upoštevajte enkratno uporabo in položaj &. Torej & je tukaj referenčni operater in ne operater-naslov. Če želite poklicati funkcijo, preprosto uporabite katero koli ime.

Referenčni identifikator ni enak identifikatorju kazalca.

Funkcija, ki vrne kazalec

V naslednjem programu funkcija vrne kazalec, ki je naslov koničastega predmeta:

#include
uporaba imenskega prostora std;
float * fn (float fl, int in)

float * fll = &fl;
vrnitev fll;

int main ()

float * val = fn (2.5, 6);
cout << *val << '\n';
vrnitev 0;

Izhod je 2.5

Prvi stavek v funkciji, fn (), obstaja samo zato, da ustvari kazalec. Upoštevajte enkratno uporabo in položaj * v podpisu funkcije. Upoštevajte tudi, kako je kazalec (naslov) v funkciji main () sprejel drug predmet kazalca.

Funkcija, ki vrne sklic

V naslednjem programu funkcija vrne sklic:

#include
uporaba imenskega prostora std;
float & fn (float fl, int in)

float & frr = fl;
vrnitev frr;

int main ()

float & val = fn (2.5, 6);
cout << val << '\n';
vrnitev 0;

Izhod je 2.5.

Prvi stavek v funkciji, fn (), je tam samo zato, da ustvari sklic. Upoštevajte enkratno uporabo in položaj & v podpisu funkcije. Upoštevajte tudi, kako je referenco v funkciji main () sprejela druga referenca.

Prenos kazalca na funkcijo

V naslednjem programu se kot argument funkciji pošlje kazalec, ki je pravzaprav naslov plavajočega koničastega predmeta:

#include
uporaba imenskega prostora std;
float fn (float * fl, int in)

vrnitev * fl;

int main ()

float v = 2.5;
float val = fn (& v, 6);
cout << val << '\n';
vrnitev 0;

Izhod je 2.5

Upoštevajte uporabo in položaj * parametra float v podpisu funkcije. Takoj, ko se začne vrednotenje funkcije fn (), se poda naslednja izjava:

float * fl = & v;

Tako fl kot & v kažeta na isti koničasti predmet, ki ima 2.5. * fl na povratni izjavi ni izjava; to pomeni vrednost koničastega predmeta, na katerega kaže kazalec.

Prenos reference na funkcijo

V naslednjem programu je referenca poslana kot argument funkcije:

#include
uporaba imenskega prostora std;
float fn (float & fl, int in)

vrnitev fl;

int main ()

float v = 2.5;
float val = fn (v, 6);
cout << val << '\n';
vrnitev 0;

Izhod je 2.5

Upoštevajte uporabo in položaj & za parameter float v podpisu funkcije. Takoj, ko se začne vrednotenje funkcije fn (), se poda naslednja izjava:

float & fl = v;

Posredovanje polja funkciji

Naslednji program prikazuje, kako posredovati matriko funkciji:

#include
uporaba imenskega prostora std;
int fn (int arra [])

vrnitev arra [2];

int main ()

int arr [] = 000, 100, 200, 300, 400;
int val = fn (arr);
cout << val << '\n';
vrnitev 0;

Izhod je 200.

V tem programu je posredovana matrika. Upoštevajte, da ima parameter podpisa funkcije prazno izjavo polja. Argument v klicu funkcije je samo ime ustvarjene matrike.

Ali lahko funkcija C ++ vrne matriko?

Funkcija v jeziku C ++ lahko vrne vrednost polja, vendar ne more vrniti polja. Pri prevajanju naslednjega programa se prikaže sporočilo o napaki:

#include
uporaba imenskega prostora std;
int fn (int arra [])

vrnitev arra;

int main ()

int arr [] = 000, 100, 200, 300, 400;
int val = fn (arr);
vrnitev 0;

Kazalec kazalca

Kazalec lahko kaže na drug kazalec. To pomeni, da ima lahko kazalec predmet naslov drugega kazalca. Še vedno morajo biti vsi iste vrste. To ponazarja naslednji segment kode:

int ptdInt = 5;
int * ptrInt = &ptdInt;
int ** ptrptrInt = &ptrInt;
cout << **ptrptrInt << '\n';

Izhod je 5.

V izjavi kazalca na kazalec se uporablja dvojnik *. Za vrnitev vrednosti končnega koničastega predmeta se še vedno uporablja dvojni *.

Niz kazalcev

Naslednji program prikazuje, kako kodirati vrsto kazalcev:

#include
uporaba imenskega prostora 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 [] = št0, št1, št2, št3, št4;
cout << *arr[4] << '\n';
vrnitev 0;

Rezultat je:

400

Upoštevajte uporabo in položaj * v deklaraciji matrike. Upoštevajte uporabo * pri vračanju vrednosti v matriki. Pri kazalcih kazalcev sta vključena dva *. V primeru polja kazalcev je za en * že poskrbljeno, ker je identifikator polja kazalec.

Niz nizov spremenljive dolžine

Niz literala je konstanta, ki vrne kazalec. Niz nizov spremenljive dolžine je niz kazalcev. Vsaka vrednost v matriki je kazalec. Kazalci so naslovi na pomnilniške lokacije in so enake velikosti. Strune različnih dolžin so drugje v pomnilniku in ne v matriki. Naslednji program ponazarja uporabo:

#include
uporaba imenskega prostora std;
int main ()

const char * arr [] = "ženska", "fant", "deklica", "odrasla oseba";
cout << arr[2] << '\n';
vrnitev 0;

Rezultat je "dekle".

Izjava matrike se začne z rezervirano besedo, "const" za konstanto; čemur sledi znak "char" za znak, nato zvezdica, * kar pomeni, da je vsak element kazalec. Če želite vrniti niz iz polja, se * ne uporablja zaradi implicitne narave kazalca vsakega niza. Če uporabite *, bo vrnjen prvi element niza.

Kazalec na funkcijo, ki vrne kazalec

Naslednji program prikazuje, kako je kodiran kazalec na funkcijo, ki vrača kazalec:

#include
uporaba imenskega prostora std;
int * fn ()

int število = 4;
int * inter = #
vrnitev inter;

int main ()

int * (* func) () = &fn;
int val = * func ();
cout << val << '\n';
vrnitev 0;

Izhod je 4.

Izjava kazalca na funkcijo, ki vrne kazalec, je podobna izjavi kazalca na običajno funkcijo, vendar pred zvezdico. To ponazarja prvi stavek v funkciji main (). Če želite funkcijo poklicati s kazalcem, pred njo pritisnite *.

Zaključek

Če želite ustvariti kazalec na skalar, naredite nekaj takega,

plovec koničast;
float * kazalec = &pointed;

* ima dva pomena: v deklaraciji pomeni kazalec; če želite nekaj vrniti, je to za vrednost koničastega predmeta.

Ime polja je konstanten kazalec na prvi element polja.

Če želite ustvariti kazalec na funkcijo, lahko to storite,

int (* func) () = &fn;

kjer je fn () funkcija, definirana drugje, funkc pa kazalec.

& ima dva pomena: v izjavi označuje sklic (sopomenko) na isti predmet kot drug identifikator; ko nekaj vrnete, to pomeni naslov.

Če želite ustvariti sklic na funkcijo, lahko to storite,

float (& refFunc) (float, int) = fn;

kjer je fn () funkcija, definirana drugje, refFunc pa referenca.

Ko funkcija vrne kazalec, mora vrnjeno vrednost sprejeti kazalec. Ko funkcija vrne referenco, mora vrnjeno vrednost sprejeti referenca.

Pri posredovanju kazalca na funkcijo je parameter deklaracija, medtem ko je argument naslov usmerjenega predmeta. Pri posredovanju sklica na funkcijo je parameter deklaracija, medtem ko je argument sklic.

Pri posredovanju matrike funkciji je parameter deklaracija, medtem ko je argument ime matrike brez []. Funkcija C ++ ne vrne matrike.

Kazalec na kazalec potrebuje dva * namesto enega, kjer je to primerno.

Chrys