Kā izmantot C ++ rādītājus

Datora atmiņa ir gara šūnu sērija. Katras šūnas lielumu sauc par baitu. Baits ir telpa, kuru aizņem alfabēta raksturs angļu valodā. Objekts parastajā nozīmē ir secīgs baitu kopums atmiņā. Katrai šūnai ir adrese, kas ir vesels skaitlis, parasti raksta heksadecimālā formā. Ir trīs veidi, kā piekļūt atmiņā esošam objektam. Objektam var piekļūt, izmantojot tā dēvēto rādītāju. Tam var piekļūt, izmantojot tā saukto atsauci. Tam joprojām var piekļūt, izmantojot identifikatoru. Šī raksta uzmanības centrā ir norāžu un atsauču izmantošana. Programmā C ++ ir vērsts objekts un rādītāja objekts. Smailajam objektam ir interesējošs objekts. Rādītāja objektam ir adrese uz smailu objektu.

Jums jābūt pamatzināšanām C ++, ieskaitot tās identifikatorus, funkcijas un masīvus; lai saprastu šo rakstu.

Rādītāja objektam un smailajam objektam katram ir savs identifikators.

Operatora adrese un

Tas ir unārs operators. Kad seko identifikators, tas atgriež identifikatora objekta adresi. Apsveriet šādu paziņojumu:

int ptdInt;

Zemāk ir kods: šī izteiksme atgriezīs ptdInt identificēto adresi:

& ptdInt

Kodējot, jums nav jāzina precīza adrese (numurs).

Netiešais operators *

Rādītāju kontekstā tas ir nevienmērīgs operators. Parasti to drukā identifikatora priekšā. Ja to izmanto identifikatora deklarācijā, identifikators ir rādītāja objekts, kuram ir tikai smailā objekta adrese. Ja kaut ko atgriež, to izmanto rādītāja objekta identifikatora priekšā, tad atgrieztā lieta ir smailā objekta vērtība.

Rādītāja izveide

Apskatiet šādu koda segmentu:

pludiņš ptdFloat;
pludiņš * ptrFloat;
ptrFoat = &ptdFloat;

Segments sākas ar smaila objekta ptdFloat deklarāciju. ptdFloat ir identifikators, kas tikai identificē pludiņa objektu. Tam varēja piešķirt faktisku objektu (vērtību), taču šajā gadījumā tam nekas nav piešķirts. Nākamais segmentā ir rādītāja objekta deklarācija. Netiešo sakaru operators šī identifikatora priekšā nozīmē, ka tam ir jāsatur smaila objekta adrese. Objekta tips, kas atrodas paziņojuma sākumā, nozīmē, ka smails objekts ir pludiņš. Rādītāja objekts vienmēr ir tāda paša veida kā smailais objekts. ptrFoat ir identifikators, kas tikai identificē rādītāja objektu.

Pēdējā koda paziņojumā norādītā objekta adrese tiek piešķirta rādītāja objektam. Ievērojiet operatora address-use izmantošanu.

Pēdējais paziņojums (rinda) iepriekš parāda, ka pēc rādītāja objekta deklarēšanas bez inicializācijas jums nav nepieciešams indirection operators, kad tas ir jāinicializē. Faktiski tā ir sintakses kļūda, ja izmantojat indirection operatoru trešajā (pēdējā) rindā.

Rādītāja objektu var deklarēt un inicializēt ar smailo objektu vienā paziņojumā šādi:

pludiņš ptdFloat;
pludiņš * ptrFoat = &ptdFloat;

Iepriekšējā un šī koda segmenta pirmā rinda ir vienāda. Iepriekšējā koda segmenta otrā un trešā rinda šeit ir apvienota vienā paziņojumā.

Ievērojiet iepriekš minētajā kodā, ka, deklarējot un inicializējot rādītāja objektu, ir jāizmanto indirection operators. Tomēr to neizmanto, ja inicializācija jāveic pēc tam. Rādītāja objekts tiek inicializēts ar smailā objekta adresi.

Šajā koda segmentā indirection operators tiek izmantots, lai atgrieztu smailā objekta saturu.

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

Rezultāts ir 5.

Pēdējā šeit sniegtajā norādē netiešo sakaru operators ir izmantots, lai atgrieztu vērtību, uz kuru norāda rādītāja identifikators. Tātad, ja to izmanto deklarācijā, indirection operatora identifikatoram būtu smailā objekta adrese. Lietojot atgriešanās izteiksmē kopā ar rādītāja identifikatoru, netiešo sakaru operators atgriež smailā objekta vērtību.

Nulles piešķiršana rādītājam

Rādītāja objektam vienmēr jābūt smailā objekta tipam. Deklarējot rādītāja objektu, jāizmanto smailā objekta datu tips. Tomēr rādītāja nulles vērtību var piešķirt rādītājam tāpat kā šādā koda segmentā:

int ptdInt = 5;
int * ptrInt;
ptrInt = 0;
vai segmentā,
int ptdInt = 5;
int * ptrInt = 0;

Jebkurā gadījumā rādītāju (identifikatoru) sauc par nulles rādītāju; nozīmē, tas norāda uz nekurieni. Tas ir, tam nav neviena smaila objekta adreses. Šeit 0 ir decimālā nulle, nevis heksadecimālā nulle. Heksadecimālā nulle norādīs uz datora atmiņas pirmo adresi.

Nemēģiniet iegūt vērtību, uz kuru norāda nulles rādītājs. Ja jūs to mēģināt, programma var kompilēt, bet var neizpildīt.

Masīva nosaukums kā pastāvīgs rādītājs

Apsveriet šādu masīvu:

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

Masīva nosaukums arr ir faktiski identifikators, kuram ir masīva pirmā elementa adrese. Šī izteiksme atgriež masīva pirmo vērtību:

* ier

Izmantojot masīvu, pieauguma operators ++ rīkojas atšķirīgi. Tā vietā, lai pievienotu 1, tā aizstāj rādītāja adresi ar masīva nākamā elementa adresi. Tomēr masīva nosaukums ir nemainīgs rādītājs; kas nozīmē, ka tā saturu (adresi) nevar mainīt vai palielināt. Tātad, lai palielinātu, masīva sākuma adrese ir jāpiešķir nepastāvīgam rādītājam šādi:

int * ptr = arr;

Tagad ptr var palielināt, lai norādītu uz nākamo masīva elementu. ptr šeit ir deklarēts kā rādītāja objekts. Bez * šeit tas nebūtu rādītājs; identifikators būtu turēt int objektu, nevis atmiņas adresi.

Šis koda segments beidzot norāda uz ceturto elementu:

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

Šis kods izvada masīva ceturto vērtību:

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

Rezultāts ir 300.

Funkcijas nosaukums kā identifikators

Funkcijas nosaukums ir funkcijas identifikators. Apsveriet šādu funkcijas definīciju:

int fn ()

cout << "seen" << '\n';
atgriešanās 4;

fn ir funkcijas identifikators. Izteiksme,

& fn

atgriež atmiņā funkcijas adresi. fn ir kā smails objekts. Šī deklarācija deklarē funkcijas rādītāju:

int (* func) ();

Smailā objekta identifikators un rādītāja objekta identifikators ir atšķirīgs. func ir rādītājs funkcijai. fn ir funkcijas identifikators. Tātad, func var norādīt uz fn šādi:

func = &fn;

Funkcijas func vērtība (saturs) ir fn adrese. Abi identifikatori varēja būt saistīti ar inicializācijas paziņojumu šādi:

int (* func) () = &fn;

Ievērojiet atšķirības un līdzības, apstrādājot funkciju rādītājus un skalāros rādītājus. func ir rādītājs funkcijai; tas ir smails objekts; tas tiek deklarēts atšķirīgi no skalārā rādītāja.

Funkciju var izsaukt ar,

fn ()
vai
func ()

To nevar izsaukt ar * func ().

Ja funkcijai ir parametri, otrajās iekavās ir parametru tipi, un tiem nav jābūt parametru identifikatoriem. To ilustrē šāda programma:

# iekļaut
izmantojot nosaukumvietu std;
float fn (float fl, int in)

atgriešanās fl;

int main ()

pludiņš (* func) (pludiņš, int) = &fn;
pludiņš val = func (2.5, 6);
cout << val << '\n';
atgriešanās 0;

Rezultāts ir 2.5.

C ++ atsauce

Atsauces C ++ ir tikai veids, kā izveidot identifikatora sinonīmu (citu vārdu). Tas izmanto & operatoru, bet ne tādā pašā veidā kā & izmanto rādītājiem. Apsveriet šādu koda segmentu:

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

Rezultāts ir:

8
8

Pirmais paziņojums inicializē identifikatoru myInt; i.e. myInt ir deklarēts un tiek turēts vērtības turēšanai, 8. Otrais paziņojums padara jaunu identifikatoru, yourInt sinonīms myInt. Lai to panāktu, & operators deklarācijā tiek ievietots starp datu tipu un jauno identifikatoru. Cout paziņojumi parāda, ka abi identifikatori ir sinonīmi. Lai atgrieztu vērtību šajā gadījumā, jums nav nepieciešams pirms tās ievadīt ar * . Vienkārši izmantojiet identifikatoru.

myInt un yourInt šeit nav divi dažādi objekti. Tie ir divi dažādi identifikatori, kas norāda (identificē) vienu un to pašu vietu atmiņā ar vērtību 8. Ja myInt vērtība tiek mainīta, arī yourInt vērtība mainīsies automātiski. Ja jūsuInt vērtība tiek mainīta, arī myInt vērtība mainīsies automātiski.

Atsauces ir viena veida.

Atsauce uz funkciju

Tāpat kā jums var būt atsauce uz skalāru, jums var būt arī atsauce uz funkciju. Tomēr atsauces uz funkciju kodēšana atšķiras no norādes uz skalāru. To ilustrē šāda programma:

# iekļaut
izmantojot nosaukumvietu std;
float fn (float fl, int in)

atgriešanās fl;

int main ()

pludiņš (& func) (pludiņš, int) = fn;
pludiņš val = func (2.5, 6);
cout << val << '\n';
atgriešanās 0;

Rezultāts ir 2.5.

Ievērojiet galveno funkciju pirmo paziņojumu, kas padara funkciju fun par fn sinonīmu. Abi atsaucas uz to pašu funkciju. Ievērojiet vienreizēju lietošanu un. Tātad šeit ir atsauces operators, nevis operatora adrese. Lai izsauktu funkciju, vienkārši izmantojiet kādu no nosaukumiem.

Atsauces identifikators nav tas pats, kas rādītāja identifikators.

Funkcija, kas atgriež rādītāju

Šajā programmā funkcija atgriež rādītāju, kas ir smailā objekta adrese:

# iekļaut
izmantojot nosaukumvietu std;
pludiņš * fn (pludiņš fl, int iekšā)

pludiņš * fll = &fl;
atgriešanās fll;

int main ()

pludiņš * val = fn (2.5, 6);
cout << *val << '\n';
atgriešanās 0;

Rezultāts ir 2.5

Funkcijas pirmais paziņojums fn () ir paredzēts tikai rādītāja objekta izveidei. Funkcijas parakstā ņemiet vērā vienreiz lietojamo un * pozīciju. Ņemiet vērā arī to, kā rādītāju (adresi) main () funkcija saņēma cits rādītāja objekts.

Funkcija, kas atgriež atsauci

Šajā programmā funkcija atgriež atsauci:

# iekļaut
izmantojot nosaukumvietu std;
float & fn (float fl, int in)

pludiņš & frr = fl;
atgriešanās frr;

int main ()

pludiņš & val = fn (2.5, 6);
cout << val << '\n';
atgriešanās 0;

Rezultāts ir 2.5.

Funkcijas pirmais paziņojums fn () ir paredzēts tikai atsauces izveidei. Funkcijas parakstā ņemiet vērā vienreizēju lietošanu un & pozīciju. Ņemiet vērā arī to, kā galvenā () funkcija saņēma atsauci ar citu atsauci.

Rādītāja nodošana funkcijai

Nākamajā programmā rādītājs, kas faktiski ir pludiņa smaila objekta adrese, tiek nosūtīts kā arguments funkcijai:

# iekļaut
izmantojot nosaukumvietu std;
pludiņš fn (pludiņš * fl, int iekšā)

atgriešanās * fl;

int main ()

pludiņš v = 2.5;
pludiņš val = fn (& v, 6);
cout << val << '\n';
atgriešanās 0;

Rezultāts ir 2.5

Funkcijas parakstā ņemiet vērā pludiņa parametra * lietojumu un pozīciju. Tiklīdz tiek sākta funkcijas fn () novērtēšana, tiek izteikts šāds paziņojums:

pludiņš * fl = & v;

Gan fl, gan & v norāda uz to pašu smailu objektu, kas tur 2.5. * atgriešanās paziņojumā fl nav deklarācija; tas nozīmē smailā objekta vērtību, uz kuru norāda rādītāja objekts.

Funkcijas atsauces nodošana

Šajā programmā atsauce tiek nosūtīta kā arguments uz funkciju:

# iekļaut
izmantojot nosaukumvietu std;
pludiņš fn (pludiņš un fl, int iekšā)

atgriešanās fl;

int main ()

pludiņš v = 2.5;
pludiņš val = fn (v, 6);
cout << val << '\n';
atgriešanās 0;

Rezultāts ir 2.5

Funkcijas parakstā ņemiet vērā parametra & izmantošanu un pozīciju. Tiklīdz tiek sākta funkcijas fn () novērtēšana, tiek izteikts šāds paziņojums:

pludiņš & fl = v;

Masīva nodošana funkcijai

Šī programma parāda, kā nodot masīvu funkcijai:

# iekļaut
izmantojot nosaukumvietu std;
int fn (int arra [])

atgriezties uz [2];

int main ()

int arr [] = 000, 100, 200, 300, 400;
int val = fn (arr);
cout << val << '\n';
atgriešanās 0;

Rezultāts ir 200.

Šajā programmā tiek nodots masīvs. Ņemiet vērā, ka funkcijas paraksta parametram ir tukša masīva deklarācija. Funkcijas izsaukuma arguments ir tikai izveidota masīva nosaukums.

Vai funkcija C ++ var atgriezt masīvu?

Funkcija C ++ var atgriezt masīva vērtību, bet nevar atgriezt masīvu. Šīs programmas sastādīšana rada kļūdas ziņojumu:

# iekļaut
izmantojot nosaukumvietu std;
int fn (int arra [])

atgriezties uz;

int main ()

int arr [] = 000, 100, 200, 300, 400;
int val = fn (arr);
atgriešanās 0;

Rādītāja rādītājs

Rādītājs var norādīt uz citu rādītāju. Tas ir, rādītāja objektam var būt cita rādītāja objekta adrese. Viņiem visiem joprojām jābūt viena tipa. To ilustrē šāds koda segments:

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

Rezultāts ir 5.

Rādītāja rādītāja deklarācijā tiek izmantots dubultā *. Lai atgrieztu galīgā smailā objekta vērtību, joprojām tiek izmantots dubultā *.

Rādītāju masīvs

Šī programma parāda, kā kodēt rādītāju masīvu:

# iekļaut
izmantojot nosaukumvietu 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';
atgriešanās 0;

Rezultāts ir:

400

Masīva deklarācijā ņemiet vērā * lietojumu un pozīciju. Atgriežot masīva vērtību, ņemiet vērā * lietojumu. Ar rādītāju rādītājiem ir iesaistīti divi *. Rādītāju masīva gadījumā viens * jau ir sarūpēts, jo masīva identifikators ir rādītājs.

Mainīga garuma virkņu masīvs

Virknes literālis ir konstante, kas atgriež rādītāju. Mainīga garuma virkņu masīvs ir rādītāju masīvs. Katra masīva vērtība ir rādītājs. Norādes ir adreses uz atmiņas vietām un ir vienāda lieluma. Dažāda garuma virknes ir citur atmiņā, nevis masīvā. Lietošanu ilustrē šāda programma:

# iekļaut
izmantojot nosaukumvietu std;
int main ()

const char * arr [] = "sieviete", "zēns", "meitene", "pieaugušais";
cout << arr[2] << '\n';
atgriešanās 0;

Rezultāts ir "meitene".

Masīva deklarācija sākas ar rezervēto vārdu “konst” konstante; seko rakstzīmei “char”, pēc tam zvaigznīte *, lai norādītu, ka katrs elements ir rādītājs. Lai atgrieztu virkni no masīva, * netiek izmantots katras virknes rādītāja netiešā rakstura dēļ. Ja tiek izmantots *, tad pirmais virknes elements tiks atgriezts.

Rādītājs funkcijai, kas atgriež rādītāju

Šī programma parāda, kā tiek kodēts rādītājs funkcijai, kas atgriež rādītāju:

# iekļaut
izmantojot nosaukumvietu std;
int * fn ()

int num = 4;
int * inter = #
atgriešanās starp;

int main ()

int * (* func) () = &fn;
int val = * func ();
cout << val << '\n';
atgriešanās 0;

Rezultāts ir 4.

Rādītāja deklarēšana funkcijai, kas atgriež rādītāju, ir līdzīga rādītāja deklarēšanai parastajai funkcijai, bet pirms tās ir zvaigznīte. Pirmais paziņojums galvenajā () funkcijā to ilustrē. Lai izsauktu funkciju, izmantojot rādītāju, pirms tās nospiediet *.

Secinājums

Lai izveidotu skalāra rādītāju, rīkojieties šādi:,

pludiņš smails;
pludiņš * rādītājs = &pointed;

* ir divas nozīmes: deklarācijā tas norāda rādītāju; kaut ko atdot, tas ir smailā objekta vērtībai.

Masīva nosaukums ir nemainīgs rādītājs uz masīva pirmo elementu.

Lai izveidotu rādītāju funkcijai, varat to izdarīt,

int (* func) () = &fn;

kur fn () ir funkcija, kas definēta citur, un func ir rādītājs.

& ir divas nozīmes: deklarācijā tas norāda atsauci (sinonīmu) uz to pašu objektu kā citu identifikatoru; kaut ko atdodot, tas nozīmē adresi.

Lai izveidotu atsauci uz funkciju, varat to izdarīt,

pludiņš (& refFunc) (pludiņš, int) = fn;

kur fn () ir funkcija, kas definēta citur, un refFunc ir atsauce.

Kad funkcija atgriež rādītāju, atgrieztā vērtība ir jāsaņem rādītājam. Kad funkcija atgriež atsauci, atgrieztā vērtība ir jāsaņem atsaucei.

Nododot rādītāju funkcijai, parametrs ir deklarācija, bet arguments ir smaila objekta adrese. Nododot atsauci uz funkciju, parametrs ir deklarācija, bet arguments ir atsauce.

Nododot masīvu funkcijai, parametrs ir deklarācija, bet arguments ir masīva nosaukums bez []. Funkcija C ++ neatgriež masīvu.

Vajadzības gadījumā rādītājam-rādītājam ir vajadzīgi divi *, nevis viens.

Chrys