Rādītāji ir simbolisks adrešu attēlojums. Tie ļauj programmām simulēt zvanu pēc atsauces, kā arī izveidot un manipulēt ar dinamiskām datu struktūrām. Atkārtošana pār elementiem masīvos vai citās datu struktūrās ir viens no galvenajiem norādes lietojumiem.

Tā mainīgā adrese, ar kuru strādājat, tiek piešķirta rādītāja mainīgajam, kas norāda uz to pašu datu tipu (piemēram, int vai virkni).

lateksa matrica

Sintakse:

datatype *var_name; int *ptr; // ptr can point to an address which holds int data>

Kā lietot rādītāju?

• Definējiet rādītāja mainīgo
• Mainīgā adreses piešķiršana rādītājam, izmantojot unāro operatoru (&), kas atgriež šī mainīgā adresi.
• Piekļuve adresē saglabātajai vērtībai, izmantojot unāro operatoru (*), kas atgriež mainīgā vērtību, kas atrodas tā operanda norādītajā adresē.

Iemesls, kāpēc mēs saistām datu tipu ar rādītāju, ir ka tā zina, cik baitos dati tiek glabāti . Palielinot rādītāju, mēs palielinām rādītāju par tā datu tipa lielumu, uz kuru tas norāda.

// C++ program to illustrate Pointers #include  using namespace std; void geeks() {  int var = 20;  // declare pointer variable  int* ptr;  // note that data type of ptr and var must be same  ptr = &var;  // assign the address of a variable to a pointer  cout << 'Value at ptr = ' << ptr << '
';  cout << 'Value at var = ' << var << '
';  cout << 'Value at *ptr = ' << *ptr << '
'; } // Driver program int main()  {   geeks();   return 0; }>

Value at ptr = 0x7ffe454c08cc Value at var = 20 Value at *ptr = 20>

Atsauces un norādes

Ir 3 veidi, kā funkcijai nodot C++ argumentus:

• Zvans pēc vērtības
• Call-By-Reference ar rādītāja argumentu
• Call-By-Reference ar atsauces argumentu

// C++ program to illustrate call-by-methods #include  using namespace std; // Pass-by-Value int square1(int n) {  // Address of n in square1() is not the same as n1 in  // main()  cout << 'address of n1 in square1(): ' << &n << '
';  // clone modified inside the function  n *= n;  return n; } // Pass-by-Reference with Pointer Arguments void square2(int* n) {  // Address of n in square2() is the same as n2 in main()  cout << 'address of n2 in square2(): ' << n << '
';  // Explicit de-referencing to get the value pointed-to  *n *= *n; } // Pass-by-Reference with Reference Arguments void square3(int& n) {  // Address of n in square3() is the same as n3 in main()  cout << 'address of n3 in square3(): ' << &n << '
';  // Implicit de-referencing (without '*')  n *= n; } void geeks() {  // Call-by-Value  int n1 = 8;  cout << 'address of n1 in main(): ' << &n1 << '
';  cout << 'Square of n1: ' << square1(n1) << '
';  cout << 'No change in n1: ' << n1 << '
';  // Call-by-Reference with Pointer Arguments  int n2 = 8;  cout << 'address of n2 in main(): ' << &n2 << '
';  square2(&n2);  cout << 'Square of n2: ' << n2 << '
';  cout << 'Change reflected in n2: ' << n2 << '
';  // Call-by-Reference with Reference Arguments  int n3 = 8;  cout << 'address of n3 in main(): ' << &n3 << '
';  square3(n3);  cout << 'Square of n3: ' << n3 << '
';  cout << 'Change reflected in n3: ' << n3 << '
'; } // Driver program int main() { geeks(); }>

address of n1 in main(): 0x7fffa7e2de64 address of n1 in square1(): 0x7fffa7e2de4c Square of n1: 64 No change in n1: 8 address of n2 in main(): 0x7fffa7e2de68 address of n2 in square2(): 0x7fffa7e2de68 Square of n2: 64 Change reflected in n2: 64 address of n3 in main(): 0x7fffa7e2de6c address of n3 in square3(): 0x7fffa7e2de6c Square of n3: 64 Change reflected in n3: 64>

Programmā C++ pēc noklusējuma argumenti tiek nodoti pēc vērtības, un izsauktajā funkcijā veiktās izmaiņas netiks atspoguļotas nodotajā mainīgajā. Izmaiņas tiek veiktas klonā, ko veido izsauktā funkcija. Ja vēlamies tieši modificēt oriģinālo kopiju (īpaši, palaižot garām milzīgu objektu vai masīvu) un/vai izvairīties no papildu klonēšanas, mēs izmantojam garāmgājēju atsauci. Pass-by-atsauce ar atsauces argumentiem nav nepieciešama nekāda neveikla sintakse atsaucēm un atsaišu noņemšanai.

• Funkciju norādes valodā C
• Rādītājs uz funkciju

Masīva nosaukums kā norādes

An masīvs nosaukums satur masīva pirmā elementa adresi, kas darbojas kā nemainīgs rādītājs. Tas nozīmē, ka masīva nosaukumā saglabāto adresi nevar mainīt. Piemēram, ja mums ir masīvs ar nosaukumu val, tad val un &val[0] var lietot aizvietojami.

// C++ program to illustrate Array Name as Pointers #include  using namespace std; void geeks() {  // Declare an array  int val[3] = { 5, 10, 20 };  // declare pointer variable  int* ptr;  // Assign the address of val[0] to ptr  // We can use ptr=&val[0];(both are same)  ptr = val;  cout << 'Elements of the array are: ';  cout << ptr[0] << ' ' << ptr[1] << ' ' << ptr[2]; } // Driver program int main() { geeks(); }>

Elements of the array are: 5 10 20>

Ja rādītājs ptr tiek nosūtīts funkcijai kā arguments, masīva val var piekļūt līdzīgā veidā. Rādītājs pret masīvu

Rādītāja izteiksmes un rādītāja aritmētika

Ierobežots komplekts aritmētika darbības var veikt ar rādītājiem, kas ir:

• palielināts (++)
• samazināts (-)
• rādītājam var pievienot veselu skaitli (+ vai +=)
• no rādītāja var atņemt veselu skaitli (– vai –=)
• atšķirība starp diviem rādītājiem (p1-p2)

( Piezīme: Rādītāja aritmētikai nav nozīmes, ja vien tā netiek veikta masīvā.)

// C++ program to illustrate Pointer Arithmetic #include  using namespace std; void geeks() {  // Declare an array  int v[3] = { 10, 100, 200 };  // declare pointer variable  int* ptr;  // Assign the address of v[0] to ptr  ptr = v;  for (int i = 0; i < 3; i++) {  cout << 'Value at ptr = ' << ptr << '
';  cout << 'Value at *ptr = ' << *ptr << '
';  // Increment pointer ptr by 1  ptr++;  } } // Driver program int main() { geeks(); }>

Value at ptr = 0x7ffe5a2d8060 Value at *ptr = 10 Value at ptr = 0x7ffe5a2d8064 Value at *ptr = 100 Value at ptr = 0x7ffe5a2d8068 Value at *ptr = 200>

Papildu rādītāja apzīmējums

Apsveriet rādītāju apzīmējumu divdimensiju ciparu masīviem. apsveriet šādu deklarāciju

int nums[2][3] = { { 16, 18, 20 }, { 25, 26, 27 } };>

Kopumā skaitļi[i ][ j ] ir līdzvērtīgi *(*(nums+i)+j)

klēpjdatora ievietošanas atslēga

Rādītāji un virkņu burti

Virkņu literāļi ir masīvi, kas satur nulles beigu rakstzīmju secības. Virknes literāļi ir masīvi, kuru tips ir rakstzīme un beigu nulles rakstzīme, un katram no elementiem ir tips const char (jo virknes rakstzīmes nevar mainīt).

>

Tas deklarē masīvu ar burtisku geek attēlojumu, un pēc tam ptr tiek piešķirts rādītājs uz tā pirmo elementu. Ja iedomājamies, ka geek tiek glabāts atmiņas vietās, kas sākas ar adresi 1800, mēs varam attēlot iepriekšējo deklarāciju kā:

Tā kā norādes un masīvi izteiksmēs darbojas vienādi, ptr var izmantot, lai piekļūtu virknes literāļa rakstzīmēm. Piemēram:

char ptr = 0; char x = *(ptr+3); char y = ptr[3];>

Šeit gan x, gan y satur k, kas saglabāts 1803 (1800+3).

izņēmumu apstrādes java

Norādes uz rādītājiem

Programmā C++ mēs varam izveidot rādītāju uz rādītāju, kas savukārt var norādīt uz datiem vai citu rādītāju. Sintakse vienkārši pieprasa vienreizējo operatoru (*) katram novirzīšanas līmenim, vienlaikus deklarējot rādītāju.

char a; char *b; char ** c; a = ’g’; b = &a; c = &b;>

Šeit b norāda uz rakstzīmi, kas saglabā “g”, un c norāda uz rādītāju b.

Tukšas norādes

Šis ir īpašs rādītāja veids, kas pieejams C++, kas apzīmē tipa neesamību. Tukšas norādes ir norādes, kas norāda uz vērtību, kurai nav veida (un līdz ar to arī nenoteikts garums un nenoteiktas atsauces atcelšanas īpašības). Tas nozīmē, ka tukšajām norādēm ir liela elastība, jo tās var norādīt uz jebkuru datu tipu. Šī elastība atmaksājas. Šos rādītājus nevar tieši atsaukt. Pirms atsauces noņemšanas tie vispirms ir jāpārveido citā rādītāja veidā, kas norāda uz konkrētu datu tipu.

// C++ program to illustrate Void Pointer #include  using namespace std; void increase(void* data, int ptrsize) {  if (ptrsize == sizeof(char)) {  char* ptrchar;  // Typecast data to a char pointer  ptrchar = (char*)data;  // Increase the char stored at *ptrchar by 1  (*ptrchar)++;  cout << '*data points to a char'  << '
';  }  else if (ptrsize == sizeof(int)) {  int* ptrint;  // Typecast data to a int pointer  ptrint = (int*)data;  // Increase the int stored at *ptrchar by 1  (*ptrint)++;  cout << '*data points to an int'  << '
';  } } void geek() {  // Declare a character  char c = 'x';  // Declare an integer  int i = 10;  // Call increase function using a char and int address  // respectively  increase(&c, sizeof(c));  cout << 'The new value of c is: ' << c << '
';  increase(&i, sizeof(i));  cout << 'The new value of i is: ' << i << '
'; } // Driver program int main() { geek(); }>

*data points to a char The new value of c is: y *data points to an int The new value of i is: 11>

Nederīgas norādes

Rādītājam jānorāda uz derīgu adresi, bet ne obligāti uz derīgiem elementiem (piemēram, masīviem). Tos sauc par nederīgiem rādītājiem. Neinicializētas norādes arī nav derīgas.

int *ptr1; int arr[10]; int *ptr2 = arr+20;>

Šeit ptr1 nav inicializēts, tāpēc tas kļūst par nederīgu rādītāju, un ptr2 ir ārpus arr robežām, tāpēc tas kļūst arī par nederīgu rādītāju. (Piezīme: nederīgas norādes ne vienmēr rada kompilēšanas kļūdas)

NULL Rādītāji

A nulles rādītājs ir rādītājs, kas nekur nenorāda, nevis tikai nederīga adrese. Tālāk ir norādītas 2 metodes, kā norādīt rādītāju kā NULL;

int *ptr1 = 0; int *ptr2 = NULL;>

Rādītāju priekšrocības

• Norādes samazina kodu un uzlabo veiktspēju. Tos izmanto, lai izgūtu virknes, kokus, masīvus, struktūras un funkcijas.
• Rādītāji ļauj mums atgriezt vairākas vērtības no funkcijām.
• Papildus tam norādes ļauj mums piekļūt atmiņas vietai datora atmiņā.

Saistītie raksti:

• Necaurspīdīgs rādītājs
• Tuvi, Tāli un milzīgi rādītāji

Viktorīnas:

Linux mainīt direktorija nosaukumu

• Rādītāja pamati
• Papildu rādītājs