Cum se utilizează pointerele C ++

Memoria unui computer este o serie lungă de celule. Mărimea fiecărei celule se numește octet. Un octet este un spațiu ocupat de un caracter englezesc al alfabetului. Un obiect în sens obișnuit este un set consecutiv de octeți din memorie. Fiecare celulă are o adresă, care este un număr întreg, de obicei scris în formă hexazecimală. Există trei moduri de a accesa un obiect în memorie. Un obiect poate fi accesat folosind ceea ce este cunoscut sub numele de pointer. Poate fi accesat folosind ceea ce este cunoscut ca referință. Poate fi accesat în continuare folosind un identificator. Acest articol se concentrează pe utilizarea de indicatori și referințe. În C ++, există obiectul ascuțit și obiectul pointer. Obiectul ascuțit are obiectul de interes. Obiectul pointer are adresa către obiectul ascuțit.

Trebuie să aveți cunoștințe de bază în C ++, inclusiv identificatorii, funcțiile și matricile acestuia; pentru a înțelege acest articol.

Obiectul pointer și obiectul ascuțit, fiecare are identificatorul său.

Adresa operatorului, &

Acesta este un operator unar. Când este urmat de un identificator, acesta returnează adresa obiectului identificatorului. Luați în considerare următoarea declarație:

int ptdInt;

Mai jos este codul, următoarea expresie, va returna adresa identificată de ptdInt:

& ptdInt

Nu trebuie să știți adresa exactă (numărul) în timp ce codificați.

Operatorul de direcție, *

Acesta este un operator unar în contextul indicatoarelor. De obicei este tastat în fața unui identificator. Dacă este utilizat într-o declarație a identificatorului, atunci identificatorul este obiectul pointer care deține doar adresa obiectului arătat. Dacă este folosit în fața identificatorului obiectului pointer, pentru a returna ceva, atunci lucrul returnat este valoarea obiectului ascuțit.

Crearea unui indicator

Aruncați o privire la următorul segment de cod:

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

Segmentul începe cu declarația obiectului ascuțit, ptdFloat. ptdFloat este un identificator, care identifică doar un obiect plutitor. Un obiect (valoare) propriu-zis i s-ar fi putut atribui, dar în acest caz nu i s-a atribuit nimic. Următorul în segment, există declarația obiectului pointer. Operatorul de indirecție din fața acestui identificator înseamnă că trebuie să dețină adresa unui obiect ascuțit. Tipul de obiect, float la începutul declarației, înseamnă că obiectul ascuțit este un float. Obiectul pointer este întotdeauna de același tip cu obiectul ascuțit. ptrFoat este un identificator, care identifică doar un obiect pointer.

În ultima afirmație a codului, adresa obiectului ascuțit este atribuită obiectului pointer. Rețineți utilizarea adresei operatorului și &.

Ultima declarație (linie) de mai sus arată că, după declararea obiectului pointer fără inițializare, nu aveți nevoie de operatorul de direcție indirectă, atunci când trebuie să-l inițializați. De fapt, este o eroare de sintaxă să folosești operatorul de indirectare în a treia (ultima) linie.

Obiectul pointer poate fi declarat și inițializat de obiectul ascuțit într-o declarație, după cum urmează:

float ptdFloat;
float * ptrFoat = &ptdFloat;

Prima linie a segmentului de cod anterior și aceasta sunt aceleași. A doua și a treia linie a segmentului de cod anterior au fost combinate într-o declarație aici.

Rețineți în codul de mai sus că atunci când declarați și inițializați obiectul pointer, trebuie utilizat operatorul de indirectare. Cu toate acestea, nu este utilizat dacă inițializarea urmează să se facă ulterior. Obiectul pointer este inițializat cu adresa obiectului ascuțit.

În următorul segment de cod, operatorul de indirectare este utilizat pentru a returna conținutul obiectului arătat.

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

Ieșirea este de 5.

În ultima afirmație de aici, operatorul de indirectare a fost folosit pentru a returna valoarea indicată de către identificatorul indicatorului. Deci, atunci când este utilizat într-o declarație, identificatorul pentru operatorul de indirectare ar deține adresa obiectului arătat. Atunci când este utilizat într-o expresie returnată, în combinație cu identificatorul indicatorului, operatorul de indirectare returnează valoarea obiectului ascuțit.

Atribuirea zero la un indicator

Obiectul indicator trebuie să aibă întotdeauna tipul obiectului ascuțit. La declararea obiectului pointer, trebuie utilizat tipul de date al obiectului ascuțit. Cu toate acestea, valoarea zero zecimal poate fi atribuită indicatorului ca în următorul segment de cod:

int ptdInt = 5;
int * ptrInt;
ptrInt = 0;
sau în segment,
int ptdInt = 5;
int * ptrInt = 0;

În ambele cazuri, indicatorul (identificatorul) este numit indicatorul nul; adică nu indică nicăieri. Adică nu are adresa niciunui obiect ascuțit. Aici, 0 este zero zecimal și nu zero hexazecimal. Zero hexazecimal ar indica prima adresă a memoriei computerului.

Nu încercați să obțineți valoarea indicată de un pointer nul. Dacă încercați acest lucru, programul poate compila, dar nu poate executa.

Numele matricei ca un indicator constant

Luați în considerare următoarea matrice:

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

Numele matricei, arr este de fapt identificatorul care are adresa primului element al matricei. Următoarea expresie returnează prima valoare din matrice:

* ar

Cu tabloul, operatorul de creștere, ++ se comportă diferit. În loc să adauge 1, înlocuiește adresa indicatorului, cu adresa elementului următor din matrice. Cu toate acestea, numele matricei este un indicator constant; adică conținutul său (adresa) nu poate fi modificat sau incrementat. Deci, pentru a crește, adresa de pornire a matricei trebuie să fie atribuită unui pointer neconstant după cum urmează:

int * ptr = arr;

Acum, ptr poate fi incrementat pentru a indica următorul element al matricei. ptr a fost declarat aici ca obiect pointer. Fără * aici, nu ar fi un indicator; ar fi un identificator să dețină un obiect int și să nu dețină o adresă de memorie.

Următorul segment de cod indică în cele din urmă al patrulea element:

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

Următorul cod afișează a patra valoare a matricei:

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

Ieșirea este de 300.

Numele funcției ca identificator

Numele unei funcții este identificatorul funcției. Luați în considerare următoarea definiție a funcției:

int fn ()

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

fn este identificatorul funcției. Expresia,

& fn

returnează adresa funcției din memorie. fn este ca obiectul ascuțit. Următoarea declarație declară un pointer către o funcție:

int (* func) ();

Identificatorul pentru obiectul ascuțit și identificatorul pentru obiectul pointer sunt diferite. func este un pointer către o funcție. fn este identificatorul unei funcții. Și astfel, funcțiile pot fi făcute să indice spre fn după cum urmează:

func = &fn;

Valoarea (conținutul) funcției este adresa lui fn. Cei doi identificatori ar fi putut fi legați cu o declarație de inițializare după cum urmează:

int (* func) () = &fn;

Rețineți diferențele și asemănările în tratarea indicatorilor funcționali și a indicatorilor scalari. func este un pointer către o funcție; este obiectul ascuțit; este declarat diferit de un pointer scalar.

Funcția poate fi apelată cu,

fn ()
sau
func ()

Nu poate fi apelat cu * func ().

Când funcția are parametri, a doua paranteză are tipurile de parametri și nu trebuie să aibă identificatori pentru parametri. Următorul program ilustrează acest lucru:

#include
folosind spațiul de nume std;
float fn (float fl, int in)

retur fl;

int main ()

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

Ieșirea este 2.5.

Referință C ++

Referirea în C ++ este doar o modalitate de a produce un sinonim (un alt nume) pentru un identificator. Folosește operatorul &, dar nu în același mod în care se folosește & pentru pointeri. Luați în considerare următorul segment de cod:

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

Ieșirea este:

8
8

Prima declarație inițializează identificatorul, myInt; eu.e. myInt este declarat și făcut să păstreze valoarea, 8. A doua afirmație face un nou identificator, yourInt un sinonim cu myInt. Pentru a realiza acest lucru, operatorul & este plasat între tipul de date și noul identificator din declarație. Declarațiile cout arată că cei doi identificatori sunt sinonime. Pentru a returna valoarea în acest caz, nu trebuie să o precedați cu * . Folosiți doar identificatorul.

myInt și yourInt aici, nu sunt două obiecte diferite. Sunt doi identificatori diferiți care fac referire (identifică) aceeași locație în memorie având valoarea, 8. Dacă valoarea myInt este modificată, valoarea yourInt se va schimba, de asemenea, automat. În cazul în care valoarea myInt este modificată, valoarea myInt se va schimba automat.

Referințele sunt de același tip.

Referință la o funcție

Așa cum puteți avea o referință la un scalar, puteți avea și o referință la o funcție. Cu toate acestea, codarea unei referințe la o funcție este diferită de codarea unei referințe la un scalar. Următorul program ilustrează acest lucru:

#include
folosind spațiul de nume std;
float fn (float fl, int in)

retur fl;

int main ()

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

Ieșirea este 2.5.

Rețineți prima afirmație din funcția principală, care face din func un sinonim al lui fn. Ambele fac referire la aceeași funcție. Rețineți utilizarea unică și poziția &. Deci & este operatorul de referință aici și nu adresa operatorului. Pentru a apela funcția, trebuie doar să folosiți oricare nume.

Un identificator de referință nu este același cu un identificator de pointer.

Funcția de returnare a unui Pointer

În următorul program, funcția returnează un pointer, care este adresa obiectului ascuțit:

#include
folosind spațiul de nume std;
float * fn (float fl, int in)

plutitor * fll = &fl;
return fll;

int main ()

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

Ieșirea este 2.5

Prima afirmație din funcție, fn () este acolo doar pentru a crea un obiect pointer. Rețineți utilizarea unică și poziția * în semnătura funcției. Rețineți, de asemenea, cum pointerul (adresa) a fost primit în funcția main () de un alt obiect pointer.

Funcție care returnează o referință

În următorul program, funcția returnează o referință:

#include
folosind spațiul de nume std;
float & fn (float fl, int in)

plutitor & frr = fl;
retur frr;

int main ()

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

Ieșirea este 2.5.

Prima afirmație din funcție, fn () este acolo doar pentru a crea o referință. Rețineți utilizarea unică și poziția & în semnătura funcției. Rețineți, de asemenea, modul în care referința a fost primită în funcția main () de o altă referință.

Trecerea unui indicator către o funcție

În următorul program, un pointer, care este de fapt adresa unui obiect cu vârf plutitor, este trimis ca argument către funcție:

#include
folosind spațiul de nume std;
float fn (float * fl, int in)

retur * fl;

int main ()

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

Ieșirea este 2.5

Rețineți utilizarea și poziția * pentru parametrul float în semnătura funcției. De îndată ce începe evaluarea funcției fn (), se face următoarea afirmație:

plutitor * fl = & v;

Atât fl cât și & v indică același obiect ascuțit care conține 2.5. * fl la declarația de returnare nu este o declarație; înseamnă valoarea obiectului ascuțit indicat de obiectul pointer.

Trecerea unei referințe la o funcție

În următorul program, se trimite o referință ca argument la funcția:

#include
folosind spațiul de nume std;
float fn (float & fl, int in)

retur fl;

int main ()

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

Ieșirea este 2.5

Rețineți utilizarea și poziția & pentru parametrul float în semnătura funcției. De îndată ce începe evaluarea funcției fn (), se face următoarea afirmație:

plutitor & fl = v;

Trecerea unei matrice la o funcție

Următorul program arată cum să treceți o matrice către o funcție:

#include
folosind spațiul de nume std;
int fn (int arra [])

return arra [2];

int main ()

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

Ieșirea este de 200.

În acest program, matricea este transmisă. Rețineți că parametrul semnăturii funcției are o declarație de matrice goală. Argumentul din apelul de funcție este doar numele unui tablou creat.

Poate o funcție C ++ să returneze o matrice?

O funcție în C ++ poate returna valoarea unui tablou, dar nu poate returna matricea. Compilarea următorului program are ca rezultat un mesaj de eroare:

#include
folosind spațiul de nume std;
int fn (int arra [])

returnare arra;

int main ()

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

Pointer of a Pointer

Un indicator poate indica un alt indicator. Adică, un obiect pointer poate avea adresa unui alt obiect pointer. Totuși, trebuie să fie de același tip. Următorul segment de cod ilustrează acest lucru:

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

Ieșirea este de 5.

În declarația pointer-to-pointer, se folosește double *. Pentru a returna valoarea obiectului ascuțit final, se folosește în continuare dublu *.

Matrice de indicatori

Următorul program arată cum să codați o serie de indicatori:

#include
folosind spațiul de nume 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;

Ieșirea este:

400

Rețineți utilizarea și poziția * în declarația matricei. Rețineți utilizarea lui * la returnarea unei valori în matrice. Cu indicii de indicatori, sunt implicați doi *. În cazul matricei de indicatori, unul * a fost deja îngrijit, deoarece identificatorul matricei este un pointer.

Matrice de șiruri de lungime variabilă

Un literal șir este o constantă care returnează un pointer. O serie de șiruri de lungime variabilă este o serie de indicatori. Fiecare valoare din tablou este un pointer. Pointerele sunt adrese către locațiile de memorie și sunt de aceeași dimensiune. Șirurile de diferite lungimi sunt în altă parte în memorie, nu în matrice. Următorul program ilustrează utilizarea:

#include
folosind spațiul de nume std;
int main ()

const char * arr [] = "femeie", "băiat", "fată", "adult";
cout << arr[2] << '\n';
retur 0;

Rezultatul este „fată”.

Declarația matricei începe cu cuvântul rezervat, „const” pentru constantă; urmat de „char” pentru personaj, apoi de asterisc, * pentru a indica faptul că fiecare element este un indicator. Pentru a returna un șir din matrice, * nu este utilizat, din cauza naturii implicite a indicatorului fiecărui șir. Dacă se folosește *, atunci primul element al șirului va fi returnat.

Pointer către o funcție care returnează un pointer

Următorul program ilustrează modul în care este codat un pointer către o funcție care returnează un pointer:

#include
folosind spațiul de nume std;
int * fn ()

int num = 4;
int * inter = #
retur inter;

int main ()

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

Ieșirea este 4.

Declarația unui pointer la o funcție care returnează un pointer este similară cu declarația unui pointer la o funcție obișnuită, dar precedată de un asterisc. Prima afirmație din funcția main () ilustrează acest lucru. Pentru a apela funcția folosind indicatorul, precedați-o cu *.

Concluzie

Pentru a crea un pointer către un scalar, faceți ceva de genul,

plutitor ascuțit;
float * pointer = &pointed;

* are două semnificații: într-o declarație, indică un indicator; pentru a returna ceva, este pentru valoarea obiectului ascuțit.

Numele matricei este un indicator constant către primul element al matricei.

Pentru a crea un pointer către o funcție, puteți face,

int (* func) () = &fn;

unde fn () este o funcție definită în altă parte și func este indicatorul.

& are două semnificații: într-o declarație, indică o referință (sinonim) la același obiect ca un alt identificator; atunci când returnăm ceva, înseamnă adresa-de.

Pentru a crea o referință la o funcție, puteți face,

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

unde fn () este o funcție definită în altă parte și refFunc este referința.

Când o funcție returnează un pointer, valoarea returnată trebuie să fie primită de un pointer. Când o funcție returnează o referință, valoarea returnată trebuie primită de o referință.

Când treceți un pointer către o funcție, parametrul este o declarație, în timp ce argumentul este adresa unui obiect ascuțit. Când treceți o referință la o funcție, parametrul este o declarație, în timp ce argumentul este referința.

Când treceți o matrice către o funcție, parametrul este o declarație în timp ce argumentul este numele matricei fără []. Funcția C ++ nu returnează o matrice.

Un pointer-to-pointer are nevoie de două * în loc de unul, acolo unde este cazul.

Chrys