Savladavanje osnova pokazivača u C i C++ programskim jezicima

Početna » piton » Savladavanje osnova pokazivača u C i C++ programskim jezicima

Pokazivači u C i C++ imaju legendarnu reputaciju: moćni, lukavi i sposobni da sruše vaš program u tren oka ako ste neoprezni. Ipak, kada jednom zaista shvatite šta je pokazivač – samo memorijska adresa – dobar dio te misterije počinje da blijedi i dobijate pristup jednom od najsvestranijih alata u programiranju niskog nivoa i sistemskom programiranju.

Ovaj članak vas korak po korak vodi od osnovne ideje memorijskih adresa i jednostavnih pokazivača, kroz reference, nizove, klase i dinamičku memoriju, sve do slučajeva upotrebe pokazivača na pokazivač i uobičajenih zamki. Cilj je da rad s pokazivačima bude prirodan, a ne kao mračna magija, kako biste mogli razmišljati o tome šta se zaista dešava u memoriji kada se vaš kod izvršava.

Razumijevanje varijabli i memorijskih adresa

Prije nego što se dotaknete pokazivača, potrebna vam je jasna mentalna slika o tome kako se varijable nalaze u memoriji. RAM memorija računara je konceptualno dugačak niz bajtova, pri čemu je svaki bajt označen jedinstvenom numeričkom adresom. Kada deklarišete varijablu, kompajler rezerviše jedan ili više tih bajtova i povezuje tu adresu sa imenom varijable.

Zamislite varijablu kao označenu kutiju smještenu negdje u memoriji: naziv je oznaka, adresa je fizička lokacija na polici, a sadržaj je vrijednost pohranjena unutar kutije. Na primjer, ako imate int Na tipičnom Arduinu UNO, zauzimat će 2 uzastopna bajta u RAM-u, a kompajler bilježi koje su tačne adrese rezervirane za njega.

Deklaracija varijable govori kompajleru koji tip i veličinu treba rezervirati, dok definicija ili dodjeljivanje zapravo pohranjuje vrijednost na toj rezerviranoj lokaciji. Na primjer, pisanje int j; samo najavljuje varijablu i dozvoljava kompajleru da alocira memoriju, dok j = 10; upisuje numeričku vrijednost 10 u memorijske ćelije koje pripadaju j.

Interno, kompajler čuva tabelu simbola gdje mapira svako ime varijable na njenu memorijsku adresu i tip. Ako kompajler odluči da j živi na adresi 2020, možete konceptualno zamisliti situaciju ovako: identifikator j ukazuje na adresu 2020, a bajtovi na adresi 2020 sadrže binarnu reprezentaciju broja 10.

Ključno je odvojiti ideju „gdje je nešto pohranjeno“ (njegova adresa) od „šta je tamo pohranjeno“ (njegova vrijednost). U teoriji kompajlera i mnogim knjigama, lokacija se često naziva lvalue (od „vrijednosti lokacije“), dok se sadržaj naziva rvaluePokazivači služe za direktno manipulisanje tim lokacijama.

Šta je tačno pokazivač?

Pokazivač je jednostavno varijabla čija je vrijednost memorijska adresa koja pokazuje na neki drugi objekat. Ne pohranjuje same podatke, već adresu na kojoj se ti podaci nalaze. Veličina pokazivača zavisi od arhitekture mašine: na 32-bitnim x86 sistemima obično je 4 bajta, na 64-bitnim x86-64 sistemima obično je 8 bajtova, a na malim mikrokontrolerima poput Arduina adresa može stati u 2 bajta.

Kada deklarišete pokazivač, navodite ne samo da on pohranjuje adresu, već i tip objekta na koji će pokazivati. Na primjer, int* p deklarira pokazivač na intZvjezdica ovdje je dio tipa, a ne znak množenja, i govori kompajleru koliko bajtova treba pročitati ili upisati kada kasnije pristupite. *p.

Adresa operatora & daje vam adresu postojećeg objekta, koju možete pohraniti u pokazivačku varijablu. Pretpostavimo da jeste int n = 0;; zatim ovaj kod pohranjuje adresu od n u pokazivač:

Primjer: int n = 0;
int* p = &n; // p now holds the address of n

Kada pokazivač sadrži validnu adresu, operator dereferenciranja * omogućava vam pristup objektu koji se nalazi na toj adresi. If p je pokazivač na int, onda *p ponaša se kao pseudonim za stvarni cijeli broj pohranjen u memoriji. Na primjer:

Isječak: *p = 1; // writes 1 into n through the pointer
std::cout << *p; // reads the current value of n

Ključna ideja je da zvjezdica znači različite stvari u različitim kontekstima: kada se koristi u deklaraciji, formira tip pokazivača, a kada se koristi u izrazu, dereferencira pokazivač. Zamjena ove dvije uloge je jedna od klasičnih početničkih grešaka, stoga uvijek obratite pažnju na to da li deklarišete pokazivač ili ga koristite za pristup memoriji.

Na malim uređajima kao što je Arduino, pokazivač koji nije eksplicitno inicijaliziran ili sadrži validnu 16-bitnu adresu ili sadrži "smeće". Ne postoji magična "prazna" vrijednost osim ako je namjerno ne postavite na konstantu nultog pokazivača kao što je nullptr u C++. Dereferenciranje takve "smeće" adrese je gotovo siguran način da se zaključa vaš mikrokontroler.

Ispravnost konstanti i različite vrste pokazivača

Pokazivači međusobno djeluju sa const na načine koji u početku mogu biti zbunjujući, ali savladavanje ovoga je ključno za ispravno pisanje C++-a. Položaj const u odnosu na zvijezdu odlučuje da li su nepromjenjivi objekt na koji se pokazuje, sam pokazivač ili oboje.

Ako imate konstantni cijeli broj, tip pokazivača mora odražavati da ga možete samo čitati, a ne mijenjati. Zamislite ovaj kod:

Demo: auto const cn = int{0}; // cn is a constant int
int const* p = &cn; // pointer to const int

Tip p evo "pokazivača na konstantni cijeli broj": možete pročitati *p ali mu se ne može dodijeliti. Trying int* p = &cn; bila bi greška tipa, jer bi to obećavalo da možete modificirati konstantni objekt, što je jezikom zabranjeno.

Ponekad sam objekat nije konstantan, ali namjerno želite pokazivač koji dozvoljava samo čitanje kroz njega. U tom slučaju ponovo koristite int const*:

Upotreba: auto n = int{0}; // non-const int
int const* p = &n; // can read n via p, but not write through p

Primetite to int const* i const int* znači potpuno isto: cijeli broj je samo za čitanje kroz pokazivač, ali pokazivač se i dalje može promijeniti da pokazuje negdje drugdje. S druge strane, ako pišete int* const p = &n;, imate konstantni pokazivač u nekonstantni cijeli broj: adresa pohranjena u p ne može se mijenjati nakon inicijalizacije, ali vrijednost *p slobodno se mijenja.

Možete čak i kombinovati oba oblika da biste kreirali konstantni pokazivač na konstantni cijeli broj: int const* const p. To govori kompajleru da ni adresa u p niti je dozvoljeno mijenjanje vrijednosti pohranjene na toj adresi. Razumijevanje ovih varijacija pomaže vam da vrlo jasno izrazite namjeru, a kompajler će vas držati iskrenim.

Pokazivači na strukture i klase

Kada pokazivač upućuje na strukturu ili klasu, obično želite pristupiti njenom javnom interfejsu: članovima podataka i funkcijama članova. Dereferenciranje sa * i dalje radi, ali sintaksa može postati malo opširna, pa C++ pruža operator strelice -> kao skraćenica.

Razmotrite jednostavno Student struktura s ocjenama i metodom koja izračunava prosjek. If Student* p sadrži adresu Student objekt, možete pisati (*p).grade_2 da stigne do drugog razreda, ili (*p).average() da pozovete funkciju člana.

Operator strelice kombinuje dereferenciranje i pristup članovima u jednom koraku: p->grade_2 i p->average() znači potpuno isto kao (*p).grade_2 i (*p).average(). Ispod haube, p->member je jednostavno sintaktički šećer za (*p).memberZato ćete gotovo uvijek vidjeti -> koristi se u stvarnom kodu pri radu s pokazivačima na objekte.

Sve dok se nastava ne preoptereti operator* or operator-> s nekim egzotičnim ponašanjem, možete počastiti p->member kao standardni način pristupa objektu iza pokazivača. Mnogi okviri se oslanjaju na preopterećenje ovih operatora za pametne pokazivače, ali konceptualno, oni zadržavaju isto značenje: pratiti pokazivač, a zatim pristupiti članu.

Nulti pokazivači i sigurnost

Pokazivač koji trenutno ne referencira validan objekt se naziva null, a u modernom C++ kanonski način da se to izrazi je pomoću nullptr. pisanje int* p = nullptr; eksplicitno navodi da p još uvijek ne ukazuje ni na šta smisleno.

Dereferenciranje nultog pokazivača je nedefinirano ponašanje, koje obično dovodi do rušenja sistema, kršenja pristupa ili, na malim pločama, zamrzavanja sistema. Zato kod koji prima pokazivač kao parametar često provjerava da li je on null prije nego što ga upotrijebi. Ako vaša logika dozvoljava "nema objekta" kao značajno stanje, parametar pokazivača je prikladan, jer može nositi tu "odsutnu" informaciju putem nullptr.

Idiomatski primjer je funkcija koja pretvara string u C stilu (char const*) do std::string ali mora elegantno obraditi slučaj kada je ulazni pokazivač null. Funkcija provjerava da li je pokazivač različit od null vrijednosti prije izgradnje. std::stringAko je null, vraća prazan string umjesto dereferenciranja nevažeće adrese.

Ako je parametar obavezan i ne može biti odsutan, C++ reference su obično bolji izbor od sirovih pokazivača. Referenca se ne može ponovo postaviti i nije namijenjena da bude null, tako da sistem tipova jasno izražava očekivanje da pozivalac mora obezbijediti validan objekat. Ovo čini API sigurnijim, a kod lakšim za razmišljanje.

Pokazivači kao parametri funkcije: po vrijednosti vs. po referenci

Podrazumevano, kada prosleđujete varijablu funkciji u C ili C++, ona se prosleđuje po vrednosti: funkcija prima kopiju vrednosti argumenta, a ne originalnu varijablu. To znači da bilo koje dodjeljivanje vrijednosti parametru unutar funkcije utiče samo na lokalnu kopiju i ostavlja varijablu pozivaoca nepromijenjenom.

Ovo ponašanje je često poželjno – izoluje funkcije i izbjegava iznenađujuće nuspojave – ali ponekad zaista želite da funkcija modificira varijable pozivaoca. Možda biste pomislili na korištenje globalnih varijabli, ali kako programi rastu, globalne promjenjive brzo postaju teške za praćenje i sklone greškama.

Pokazivači nude čistu alternativu: funkciji se prosljeđuje adresa varijable, a funkcija zatim može promijeniti vrijednost na toj adresi. Ovo je poznato kao "prenošenje referencom putem pokazivača". U C++-u možete koristiti i parametre reference (int&), koji su često još jasniji, ali razumijevanje oblika pokazivača je i dalje ključno.

Zamislite funkciju double_value koji bi trebao udvostručiti cijeli broj definiran u pozivatelju. Koristeći interfejs zasnovan na pokazivačima, deklarisali biste ga kao da preuzima int*, i pozovite ga prosljeđivanjem adrese vaše varijable: double_value(&k);Unutar funkcije, *k = *k * 2; ažurira originalnu vrijednost putem pokazivača.

Ova tehnika također omogućava funkciji da efikasno "vrati" više rezultata modificiranjem nekoliko varijabli čije su adrese proslijeđene kao argumenti. Umjesto vraćanja složene strukture, možete prihvatiti nekoliko parametara pokazivača i ažurirati ih sve. U modernom C++-u biste obično favorizirali reference, tuple ili strukture radi jasnoće, ali parametri pokazivača ostaju uobičajeni u API-jima niskog nivoa i C bibliotekama.

Pokazivačka aritmetika i nizovi

Jedan od najmoćnijih – i najopasnijih – aspekata pokazivača je pokazivačka aritmetika, posebno u kontekstu nizova. U C i C++, niz se pohranjuje kao blok susjednih elemenata u memoriji, a ime niza može se pretvoriti u pokazivač na njegov prvi element kada se proslijedi funkciji ili koristi u određenim izrazima.

Ako izjavite char h[] = {'P','r','o','m','e','t','e','c','\n'};, onda h može se tretirati kao pokazivač na h[0]. Pristup h[i] je konceptualno ekvivalentno računarstvu *(h + i), gdje h je bazna adresa i i je pomak u elementima (ne u bajtovima). Kompajler množi i po veličini svakog elementa (1 bajt za char, 4 bajta za int, itd.) prije nego što ga dodate pokazivaču.

To znači da kada vidite izraz poput *(h + i), radite klasičnu pokazivačku aritmetiku: pomičete pokazivač naprijed-nazad h by i pozicije, a zatim dereferencirati rezultat. Iz razloga performansi, kompajleri su veoma dobri u optimizaciji ovog obrasca, zbog čega su C nizovi i pokazivači historijski bili tako popularna kombinacija za rad niskog nivoa.

Također možete kreirati eksplicitni pokazivač na prvi element niza i povećati taj pokazivač da biste prošli kroz niz. Na primjer, proglašavanje char* ptr = h; a zatim više puta štampati *ptr++ u petlji će prolaziti kroz svaki znak u nizu. Postfiks ++ pomiče pokazivač nakon svakog pristupa, pomjerajući ga na sljedeći element niza.

Ovaj kompaktni stil je idiomatski C, ali može biti zagonetan za početnike, tako da u modernom C++ mnogi programeri preferiraju eksplicitnije oblike kao što su for petlje s indeksima ili for petlje zasnovane na rasponu. Ipak, razumijevanje pokazivačke aritmetike je neophodno za čitanje i održavanje naslijeđenog koda, kao i za implementaciju rutina kritičnih za performanse.

Dinamička memorija, novo/brisanje i iteracija pokazivača

Pokazivači su također osnovni identifikator koji primate kada dinamički alocirate objekte na slobodnoj memoriji (često neformalno nazvanoj heap). U C++, operator new vraća pokazivač na novododijeljeni objekt i delete oslobađa tu memoriju kada vam više nije potrebna.

Na primjer, Student* p = new Student{...}; rezerviše dovoljno memorije za jednu Student objekat i vraća njegovu adresu. Zatim koristite p->member da pristupi svojim članovima ili pozove svoje metode. Kada objekat više nije potreban, delete p; uništava ga i oslobađa memoriju nazad u slobodnu pohranu.

C++ također omogućava dinamičko alokiranje nizova pomoću new[], koji vraća pokazivač na prvi element niza. Na primjer, Student* p = new Student[100]; dodjeljuje prostor za 100 Student objekti poredani neprekidno u pamćenju, sa p pokazujući na element na indeksu 0.

Korištenjem pokazivačke aritmetike, izraz p + i ukazuje na i-ti element tog niza, dakle (p + 4)->grade_1 je ekvivalentno sa p[4].grade_1. Konceptualno, p je kao iterator koji počinje od prvog elementa, i p + i unaprijedi taj iterator za i korake duž niza.

Razlike između pokazivača također imaju značenje: ako q = p + 4;, onda q - p vraća vrijednost 4, što je broj elemenata između ta dva pokazivača. U tom smislu, sirovi pokazivač je najjednostavniji oblik iteratora sa slučajnim pristupom. Mnogi STL kontejneri otkrivaju iteratore koji se ponašaju slično, ali skrivaju detalje sirovog pokazivača radi sigurnosti i fleksibilnosti.

Iako sirovo new/delete iako su moćni, moderni C++ snažno preporučuje korištenje pametnih pokazivača i RAII (Resource Acquisition Is Initialization - Prikupljanje resursa je inicijalizacija) za automatsko upravljanje resursima. Pametni pokazivači poput std::unique_ptr i std::shared_ptr enkapsuliraju vlasništvo i automatski oslobađaju memoriju kada više nije potrebna, smanjujući rizik od curenja i dvostrukog brisanja.

Pokazivači na pokazivače i dublja indirekcije

Kada se jednom upoznate s jednostavnim pokazivačima, neizbježno ćete naići na pokazivače na pokazivače (a ponekad čak i na više nivoe indirekcije). Konceptualno, pokazivač na pokazivač je samo još jedna varijabla koja sadrži adresu pokazivačke varijable, umjesto direktnog referenciranja na int, double ili objekt.

Najočigledniji slučaj upotrebe je upravljanje dinamički dodijeljenim nizovima pokazivača, kao što je dinamički izgrađena tabela dinamički dodijeljenih stringova. U običnom C-u, klasičan primjer je char** argv u main funkcija, koja je pokazivač na niz stringova u C stilu, od kojih je svaki sam po sebi char*.

Drugi čest scenario je kada funkcija mora modificirati pokazivač koji je dao pozivatelj, ne samo podatke na koje pokazuje. Prosljeđivanje pokazivača na pokazivač omogućava funkciji da promijeni na koji se objekt originalni pokazivač odnosi ili da ga inicijalizira alociranjem novog objekta sa new or mallocPozivni kod zatim vidi ažuriranu vrijednost pokazivača.

Višestruki nivoi indirekcije se također prirodno pojavljuju u određenim strukturama podataka, posebno u povezanim strukturama podataka kreiranim na hipu. Na primjer, dinamički izgrađena povezana lista čvorova kojima je dodijeljeno malloc or new može uključivati ​​pokazivače na čvorove, plus funkcije koje primaju pokazivače na te pokazivače za umetanje ili uklanjanje elemenata prilikom ažuriranja glavnog pokazivača.

I naravno, višedimenzionalni dinamički nizovi se obično predstavljaju kao pokazivači na pokazivače u interfejsima u C stilu: "matrica" ​​se obično modelira kao int**, gdje je svaki element prve dimenzije pokazivač na niz redova. U modernom C++-u možda biste preferirali std::vector<std::vector<T>> ili prilagođene matrične klase, ali rasporedi pokazivača na pokazivač ostaju fundamentalni u API-jima i povezivanjima niskog nivoa.

Uobičajene zamke i dobre prakse s uputama

Direktan rad s pokazivačima daje vam preciznu kontrolu, ali također otvara vrata suptilnim i teško ispraviti greškama ako niste disciplinovani. Mnogi legendarni bagovi u C i C++ kodnim bazama svode se na pogrešno rukovanje sirovim adresama, bilo pisanjem u memoriju koja vam ne pripada ili zaboravljanjem upravljanja životnim vijekom objekata.

Jedna klasična greška je pisanje više bajtova nego što ciljni tip može da sadrži ili pogrešno tumačenje tipa memorijske lokacije. Na primjer, ako pohranite long vrijednost u int varijabla ili napišite long na lokaciju koja je dimenzionirana samo za int, na kraju prepisujete susjednu memoriju, potencijalno oštećujući druge varijable ili čak pokazivače koda.

Druga opasnost je dodjeljivanje proizvoljnih numeričkih vrijednosti direktno pokazivačkim varijablama, kao što je ptrNum = 7;, osim ako ne radite sistemski posao izuzetno niskog nivoa i tačno znate šta se nalazi na toj adresi. Za običan aplikacijski kod, tretiranje cijelog broja kao adrese je direktna linija ka nedefinisanom ponašanju i nepravilnim padovima sistema.

Zaboravljanje pravilne inicijalizacije pokazivača je također rizično: pokazivač koji sadrži neodređenu vrijednost može izgledati u redu, ali bi mogao pokazivati ​​bilo gdje u memoriji. Uvijek inicijalizirajte pokazivače – ili na validnu adresu ili na nullptr – i provjerite ih prije dereferenciranja ako postoji bilo kakva sumnja da bi mogli biti null.

Konačno, s dinamičkom memorijom, svaki sirovi new treba se podudarati s tačno jednim odgovarajućim delete, i svaki new[] sa tačno jednim delete[]. Do curenja podataka dolazi kada izgubite trag dinamički alocirane memorije bez brisanja iste, a dvostruka brisanja (ili brisanje memorije koju ne posjedujete) oštećuju unutrašnje strukture alokatora, što se obično manifestuje kao povremeni i vrlo teško reproducirajući defekti.

Kada se s njima pažljivo rukuje, pokazivači su više poput oštrog, dobro izbalansiranog alata nego slučajnog izvora haosa: oni vam omogućavaju da razmišljate o rasporedu memorije vašeg programa, dizajnirate efikasne strukture podataka i izgradite moćne apstrakcije povrh te niskonivojske kontrole. Kako vježbate, kretanje između adresa, dereferenciranje i razumijevanje kako funkcije i nizovi interaguju s pokazivačima postaje vam druga priroda, a početni strah ustupa mjesto zdravom poštovanju i mnogo praktičnoj korisnosti.