pointers pointer operations c
Intenzivna študija kazalcev in njihove uporabe v jeziku C ++.
Kazalec je ena najmočnejših lastnosti jezika C ++. Kazalec pomaga manipulirati spremenljivke prek naslova.
kako prenesti polja v javi -
V tej vadnici bomo podrobno raziskali vse o kazalcih in njihovi uporabi v jeziku C ++.
=> Tukaj bodite pozorni na preprosto vadbeno serijo C ++.
Kaj se boste naučili:
- Kaj je kazalec?
- Aritmetika kazalca
- Kazalci ničnih in praznih
- Polja in kazalci
- Niz kazalcev
- Kazalec kazalcev
- Prenos kazalcev na funkcije
- Kazalci na funkcije
- Zaključek
- Priporočeno branje
Kaj je kazalec?
Kazalec je spremenljivka, ki vsebuje naslov pomnilniške lokacije. Vemo, da imajo vse spremenljivke, ki jih prijavimo, določen naslov v spominu. Razglasimo spremenljivko kazalca, ki kaže na te naslove v pomnilniku.
Splošna sintaksa za razglasitev spremenljivke kazalca je:
datatype * variable_name;Na primer, izjavo int * ptr;
To pomeni, da je ptr kazalec, ki kaže na spremenljivko tipa int. Zato spremenljivka kazalca vedno vsebuje pomnilniško lokacijo ali naslov. Spodaj si oglejmo delovanje kazalnih spremenljivk.
Upoštevajte, da imamo naslednje izjave:
Int p, *ptr; //declare variable p and pointer variable ptr p = 4; //assign value 4 to variable p ptr = &p; //assign address of p to pointer variable ptrV spomin bodo te izjave predstavljene na naslednji način:
To je notranja predstavitev kazalca v pomnilniku. Ko spremenljivki naslova dodelimo spremenljivko naslova, ta kaže na spremenljivko, kot je prikazano v zgornji predstavitvi.
Ker ima ptr naslov spremenljivke p, bo * ptr dal vrednost spremenljivke p (spremenljivka, na katero kaže spremenljivka kazalca ptr).
Opomba: Operator *, ki ga uporabljamo s kazalcem, se uporablja za označevanje spremenljivke kazalca.
Oglejmo si nekaj konceptov kazalcev, ki se uporabljajo v jeziku C ++.
Aritmetika kazalca
Vemo, da kazalna spremenljivka vedno kaže na naslov v pomnilniku. Med operacijami, ki jih lahko izvedemo, imamo naslednje aritmetične operacije, ki se izvajajo na kazalcih.
- Operator povečanja (++)
- Operator zmanjšanja (-)
- Dodatek (+)
- Odštevanje (-)
Oglejmo si uporabo teh operacij v primeru programa.
#include #include using namespace std; int main() { int myarray(5) = {2, 4,6, 8,10}; int* myptr; myptr = myarray; cout<<'First element in the array :'<<*myptr< Izhod:
Prvi element v matriki: 2
naslednji element v matriki: 4
naslednji element v matriki: 6
naslednji element v matriki: 4
naslednji element v matriki: 2
Videli smo aritmetične operacije na kazalcih. Upoštevajte, da operator prirastka ++ poveča kazalec in kaže na naslednji element v matriki. Podobno operater zmanjšanja zmanjša spremenljivko kazalca za 1, tako da kaže na prejšnji element v matriki.
Uporabljamo tudi operatorja + in -. Najprej smo spremenljivki kazalca dodali 1. Rezultat kaže, da kaže na naslednji element v matriki. Podobno operater naredi spremenljivko kazalca, da kaže na prejšnji element v matriki.
Poleg teh aritmetičnih operatorjev lahko uporabimo tudi operatorje primerjave, kot je ==,.
Kazalci ničnih in praznih
Če v primeru, da spremenljivki kazalca ni dodeljen naslov spremenljivke, je dobra praksa, da spremenljivki kazalca dodelite NULL vrednost. Kazalnik spremenljivke z vrednostjo NULL se imenuje kazalec NULL.
Ničelni kazalnik je konstanten kazalnik z vrednostjo nič, določeno v glavi iostream. Pomnilnik na naslovu 0 je rezerviran za operacijski sistem in do te lokacije ne moremo dostopati.
Z ničelnim kazalcem se lahko izognemo zlorabi neuporabljenih kazalcev in preprečimo, da bi spremenljivkam kazalcev dodeljene nekatere vrednosti smeti.
Prazni kazalci so posebni kazalci, ki kažejo na vrednosti brez vrste. Prazni kazalci so bolj prilagodljivi, saj lahko kažejo na katero koli vrsto. Vendar jih ni mogoče neposredno preimenovati. Za odvajanje referenc je treba kazalec void pretvoriti v kazalec, ki kaže na vrednost s konkretnim podatkovnim tipom.
Delo kazalca NULL in void smo prikazali v naslednjem primeru kode.
#include #include using namespace std; int main() { int intvar = 10; char c = 'A'; void* vptr; int* myptr = NULL; cout<<'NULL pointer value :'< Izhod:
NULL vrednost kazalca: 0
Kazalec za praznino vptr kaže na: A
Kazalec za praznino vptr kaže na: 10
V zgornjem programu najprej razglasimo celoštevilčni kazalec, ki mu je dodeljena vrednost NULL. Ko natisnemo ta kazalec, vidimo, da je vrednost 0, kot smo že omenili.
Nato razglasimo ničelni kazalec. Najprej temu praznem kazalcu dodelimo naslov spremenljivke znakov. Nato kazalcu praznine dodelimo kazalec znaka in ga vtipkamo s char *. Nato izpišemo vrednost charptr, ki kaže na char A, ki je bila spremenljivka znakov, ki smo jo deklarirali prej, in na katero kaže kazalec void.
Nato smo praznemu kazalcu dodelili celoštevilčno spremenljivko in nato izvedli iste korake preusmeritve tega praznega kazalca z uporabo celoštevilčnega kazalca.
Polja in kazalci
Nizi in kazalci so med seboj močno povezani. Vemo, da ime matrice kaže na prvi element v matriki in to je stalni kazalec.
Ta kazalnik lahko dodelimo spremenljivki kazalca in nato do matrike dostopamo z dekrementiranjem kazalca ali z uporabo operatorja podpisa.
To povezavo med kazalno spremenljivko in matriko bomo videli v naslednjem primeru kode.
#include #include using namespace std; int main() { int myarray(5) = {1, 1, 2, 3, 5}; int* ptrvar; ptrvar = myarray; for(int i=0;i<5;i++) { cout<<*ptrvar<<' '; ptrvar++; } return 0; } Izhod:
1 1 2 3 5
V zgornjem programu dodelimo ime matrike spremenljivki kazalca. Ker ime polja kaže na prvi element v polju, lahko vsebino celotnega polja natisnemo z uporabo kazalne spremenljivke in jo povečamo z operaterjem ++. To je prikazano v izhodu.
Niz kazalcev
Včasih v programu potrebujemo več spremenljivk kazalcev. Namesto da bi razglasili vsako posamezno spremenljivko kazalca, lahko prijavimo niz kazalcev.
Takoj vzemimo primer, da pokažemo vrsto kazalcev.
#include #include using namespace std; int main() { int myarray(5) = {2,4,6,8,10}; int *ptr(5); //array of pointers for(int i=0;i<5;i++){ ptr(i) = &myarray(i); } for (int i = 0; i < 5; i++) { cout << 'Value of myarray(' << i << ') = '; cout << *ptr(i) << endl; } return 0; } Izhod:
Vrednost myarray (0) = 2
Vrednost myarray (1) = 4
Vrednost myarray (2) = 6
Vrednost myarray (3) = 8
Vrednost myarray (4) = 10
V zgornji izjavi je
int * ptr (5);
vprašanja za razgovore o prijetnih spletnih storitvah
Lahko si razlagamo kot; ptr je niz 5 celoštevilnih kazalcev. Zato bo vsak element ptr kazal na spremenljivko tipa celo število.
Uporabljamo celoštevilsko matriko in vsakemu elementu ptr dodelimo naslov vsakega elementa matrike. Nato prikažemo vsebino matrike ptr z izpisom »* ptr (i)«.
Kazalec kazalcev
Kazalec kazalcev ni nič drugega kot več posrednih usmeritev. To je nekakšna veriga kazalcev. Ko definiramo kazalec kazalcev, ima prvi kazalec naslov drugega kazalca, ta pa naslov spremenljivke, na katero kaže.
V spominu bo to predstavljeno kot:
Kazalec kazalcev je razglašen na naslednji način:
int** intptr; Za boljše razumevanje kazalca kazalcev vzamemo primer kode.
#include #include using namespace std; int main() { int *vptr; int ** intptr; int var = 10; vptr = &var; intptr = &vptr; cout<<'Variable var: '< Izhod:
Spremenljivka var: 10
Kazalec na spremenljivko: 10
Kazalec na kazalec na spremenljivko: 10
V zgornjem programu razglasimo celoštevilčno spremenljivko, celoštevilčni kazalec in kazalec kazalca na celo število. Kot je prikazano v programu, je spremenljivki kazalca dodeljena vrednost spremenljivke. Kazalcu spremenljivke kazalca se dodeli naslov spremenljivke kazalca.
Na koncu izpišemo tri spremenljivke, ki prikazujejo enako vrednost 10, ki je enaka celoštevilčni spremenljivki.
Prenos kazalcev na funkcije
Prenos kazalcev v funkcijo je enak kot pri drugih tehnikah posredovanja parametrov, pri katerih funkciji posredujemo spremenljivke kazalcev.
Ponovno obiščemo zamenjavo dveh vrednosti in jo spremenimo tako, da kot parametre posredujemo spremenljivke kazalcev.
#include #include using namespace std; void swap(int* a, int* b) { int temp; temp = *a; *a = *b; *b = temp; } int main() { int a, b; cout<>a>>b; cout<<'a = '< Kazalci na funkcije na enak način, kot imamo kazalce na spremenljivke, polja itd., imamo lahko tudi kazalce na funkcije. Toda razlika je v tem, da kazalnik funkcije kaže na izvedljivo kodo in ne na podatke, kot so spremenljivke ali polja.
Za prikaz kazalcev funkcij vzamemo primer.
#include #include using namespace std; void displayVal(int a) { printf('Value of a is %d
', a); } int main() { void (*func_ptr)(int) = &displayVal; (*func_ptr)(100); return 0; } Izhod:
Vrednost a je 100
spletna mesta za prenos YouTube video posnetkov v mp3
V zgornjem programu imamo funkcijo ‘displayVal’, ki samo natisne celoštevilčno vrednost, ki ji je bila posredovana. V glavni funkciji smo definirali kazalnik funkcije 'func_ptr', ki vzame int kot argument in vrne tip void.
void (* func_ptr) (int)
Opomba: Kazalec funkcije moramo priložiti znotraj (). Če ga izpustimo, bo postal prototip funkcije.
Temu kazalcu funkcije smo dodelili naslov funkcije ‘displayVal’. Nato s pomočjo tega kazalca funkcije 'func_ptr' posredujemo vrednost argumenta 100, ki je enakovredna klicanju displayVal z argumentom 100.
Zdaj, če imamo drugo funkcijo z istim prototipom, potem lahko uporabimo isti kazalnik funkcije, tako da mu dodelimo naslov funkcije. To je glavna uporaba kazalcev funkcij.
Zaključek
To je vse o kazalcih, njihovih definicijah in uporabi v jeziku C ++.
V naslednji vadnici bomo izvedeli več o referencah v jeziku C ++. Sklici se prav tako uporabljajo v jeziku C ++ in se pogosto uporabljajo kot vzdevki za spremenljivke.
=> Kliknite tukaj za absolutno serijo usposabljanj C ++.
Priporočeno branje
