C ++

Kuinka käyttää C ++ -osoittimia

Kuinka käyttää C ++ -osoittimia
Tietokoneen muisti on pitkä solusarja. Kunkin solun kokoa kutsutaan tavuksi. Tavu on tila, jonka aakkoset käyttävät englanninkielinen merkki. Objekti tavallisessa mielessä on peräkkäinen tavujoukko muistissa. Jokaisella solulla on osoite, joka on kokonaisluku, yleensä kirjoitettuna heksadesimaalimuodossa. On kolme tapaa käyttää muistissa olevaa kohdetta. Objektiin pääsee käsiksi osoittimena. Sitä voi käyttää käyttämällä viitteenä tunnettua. Sitä voi silti käyttää tunnisteen avulla. Tämän artikkelin painopiste on viitteiden ja viitteiden käytössä. Kohdassa C ++ on terävä esine ja osoitinobjekti. Terävällä esineellä on kiinnostava kohde. Osoitinobjektilla on osoite terävään objektiin.

Sinulla on oltava perustiedot C ++: sta, mukaan lukien sen tunnisteet, toiminnot ja taulukot; ymmärtää tätä artikkelia.

Osoitinobjektilla ja terävällä objektilla on kullakin oma tunniste.

Operaattorin osoite ja

Tämä on unary operaattori. Kun sitä seuraa tunniste, se palauttaa tunnisteen objektin osoitteen. Harkitse seuraavaa julistusta:

int ptdInt;

Alla oleva koodi, seuraava lauseke, palauttaa ptdInt: n tunnistaman osoitteen:

& ptdInt

Sinun ei tarvitse tietää tarkkaa osoitetta (numeroa) koodatessasi.

Indirection-operaattori, *

Tämä on unaarinen operaattori osoittimien yhteydessä. Se kirjoitetaan yleensä tunnisteen eteen. Jos sitä käytetään tunnisteen ilmoituksessa, tunniste on osoitinobjekti, jolla on vain teräväkohteen osoite. Jos sitä käytetään osoittimen objektitunnisteen edessä jonkin palauttamiseksi, palautettu asia on teräväkohteen arvo.

Osoittimen luominen

Katso seuraava koodisegmentti:

kellua ptdFloat;
kellua * ptrFloat;
ptrFoat = &ptdFloat;

Segmentti alkaa teräväkohteen ptdFloat ilmoituksella. ptdFloat on tunniste, joka vain tunnistaa kelluvan objektin. Todellinen objekti (arvo) olisi voitu osoittaa sille, mutta tässä tapauksessa sille ei ole annettu mitään. Seuraavaksi segmentissä on osoitinobjektin ilmoitus. Indirection-operaattori tämän tunnisteen edessä tarkoittaa, että sen on pidettävä terävän objektin osoitetta. Kohdetyyppi, float lauseen alussa, tarkoittaa, että terävä esine on float. Osoitinobjekti on aina samaa tyyppiä kuin terävä esine. ptrFoat on tunniste, joka vain tunnistaa osoitinobjektin.

Koodin viimeisessä lausekkeessa osoitetaan osoitetun objektin osoite osoitinobjektille. Huomaa operaattori address-operaattorin käyttö.

Viimeinen yllä oleva lause (rivi) osoittaa, että kun olet osoittanut osoitinobjektin ilman alustusta, et tarvitse indirection-operaattoria, kun sinun on alustettava se. Itse asiassa on syntaksivirhe käyttää indirection-operaattoria kolmannella (viimeisellä) rivillä.

Terävä esine voi julistaa ja alustaa osoitinobjektin yhdessä lauseessa seuraavasti:

kellua ptdFloat;
kellua * ptrFoat = &ptdFloat;

Edellisen koodisegmentin ensimmäinen rivi ja tämä, ovat samat. Edellisen koodisegmentin toinen ja kolmas rivi on yhdistetty tässä yhdeksi lauseeksi.

Huomaa yllä olevassa koodissa, että ilmoitettaessa ja alustettaessa osoitinobjektia on käytettävä indirection-operaattoria. Sitä ei kuitenkaan käytetä, jos alustus tehdään jälkikäteen. Osoitinobjekti alustetaan teräväkohteen osoitteella.

Seuraavassa koodisegmentissä indirection-operaattoria käytetään palauttamaan terävän objektin sisältö.

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

Lähtö on 5.

Tässä viimeisessä lausunnossa indirection-operaattoria on käytetty palauttamaan osoitetun tunnisteen osoittama arvo. Joten, kun sitä käytetään ilmoituksessa, indirection-operaattorin tunniste sisältää terävän objektin osoitteen. Kun paluulauseketta käytetään yhdessä osoitintunnisteen kanssa, indirection-operaattori palauttaa teräväkohteen arvon.

Nollan osoittaminen osoittimelle

Osoitinobjektilla tulisi aina olla kärjistetyn objektin tyyppi. Osoitinobjektia ilmoitettaessa on käytettävä teräväkohteen tietotyyppiä. Desimaalisen nollan arvo voidaan kuitenkin osoittaa osoittimelle kuten seuraavassa koodisegmentissä:

int ptdInt = 5;
int * ptrInt;
ptrInt = 0;
tai segmentissä,
int ptdInt = 5;
int * ptrInt = 0;

Kummassakin tapauksessa osoitinta (tunnistetta) kutsutaan nollaosoittimeksi; tarkoittaen, se osoittaa mihinkään. Eli sillä ei ole minkään terävän objektin osoitetta. Tässä 0 on desimaalinen nolla eikä heksadesimaalinen nolla. Heksadesimaalinen nolla osoittaisi tietokoneen muistin ensimmäiseen osoitteeseen.

Älä yritä saada arvoa, johon nollaosoitin osoittaa. Jos yrität sitä, ohjelma saattaa kääntää, mutta ei välttämättä suorita.

Taulukon nimi vakiona osoittajana

Harkitse seuraavaa taulukkoa:

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

Taulukon nimi arr on itse asiassa tunniste, jolla on taulukon ensimmäisen elementin osoite. Seuraava lauseke palauttaa matriisin ensimmäisen arvon:

* arr

Matriisin avulla inkrementtioperaattori ++ käyttäytyy eri tavalla. Yhden lisäämisen sijaan se korvaa osoittimen osoitteen taulukon seuraavan elementin osoitteella. Matriisin nimi on kuitenkin vakioosoitin; eli sen sisältöä (osoitetta) ei voida muuttaa tai lisätä. Joten lisäykseksi taulukon alkuosoite on osoitettava ei-vakioosoittimelle seuraavasti:

int * ptr = arr;

Nyt ptr: tä voidaan kasvattaa osoittamaan taulukon seuraavaan elementtiin. ptr on ilmoitettu tässä osoitinobjektina. Ilman * täällä, se ei olisi osoitin; tunniste olisi int-objektin pitäminen eikä muistiosoitteen pitäminen.

Seuraava koodisegmentti osoittaa lopulta neljännen elementin:

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

Seuraava koodi antaa taulukon neljännen arvon:

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

Tuotos on 300.

Funktion nimi tunnisteena

Funktion nimi on funktion tunniste. Harkitse seuraavaa funktion määritelmää:

int fn ()

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

fn on funktion tunniste. Ilmaisu,

& fn

palauttaa muistissa olevan toiminnon osoitteen. fn on kuin terävä esine. Seuraava ilmoitus julistaa osoittimen funktiolle:

int (* func) ();

Teräväkohteen tunniste ja osoitinobjektin tunniste ovat erilaiset. func on toiminnon osoitin. fn on funktion tunniste. Ja niin, funktio voidaan saada osoittamaan fn: lle seuraavasti:

func = &fn;

Func: n arvo (sisältö) on fn: n osoite. Kaksi tunnusta olisi voitu liittää alustamislausekkeeseen seuraavasti:

int (* func) () = &fn;

Huomaa erot ja yhtäläisyydet toiminnon osoittimien ja skalaariosoittimien käsittelyssä. func on osoitin toiminnolle; se on terävä esine; se ilmoitetaan eri tavalla kuin skalaariosoitin.

Toiminto voidaan kutsua,

fn ()
tai
func ()

Sitä ei voida kutsua * func (): lla.

Kun funktiolla on parametreja, toisissa sulkeissa on parametrien tyypit, eikä niillä tarvitse olla tunnisteita parametreille. Seuraava ohjelma kuvaa tätä:

#sisältää
käyttämällä nimitilaa vakio;
float fn (float fl, int sisään)

paluu fl;

int main ()

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

Lähtö on 2.5.

C ++ -viite

Viittaaminen C ++: ssa on vain tapa tuottaa tunnukselle synonyymi (toinen nimi). Se käyttää & -operaattoria, mutta ei samalla tavalla kuin & käytetään osoittimiin. Harkitse seuraavaa koodisegmenttiä:

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

Tuotos on:

8
8

Ensimmäinen käsky alustaa tunnisteen myInt; i.e. myInt on ilmoitettu ja tehty pitämään arvo, 8. Toinen lause antaa uuden tunnisteen, yourInt-synonyymin myInt-tunnukselle. Tämän saavuttamiseksi & -operaattori sijoitetaan ilmoituksessa tietotyypin ja uuden tunnisteen väliin. Cout-lauseet osoittavat, että nämä kaksi tunnistetta ovat synonyymejä. Jos haluat palauttaa arvon tässä tapauksessa, sinun ei tarvitse edeltää sitä merkillä * . Käytä vain tunnistetta.

myInt ja yourInt täällä, eivät ole kahta erilaista esinettä. Ne ovat kaksi erilaista tunnistetta, jotka viittaavat (tunnistavat) samaan sijaintiin muistissa, jonka arvo on 8. Jos myInt: n arvoa muutetaan, myös yourInt: n arvo muuttuu automaattisesti. Jos yourInt-arvoa muutetaan, myInt-arvo muuttuu myös automaattisesti.

Viitteet ovat samantyyppisiä.

Viittaus toimintoon

Aivan kuten sinulla voi olla viittaus skalaariin, voit myös viitata toimintoon. Funktion viitteen koodaus on kuitenkin erilainen kuin skalaariin viittauksen koodaus. Seuraava ohjelma kuvaa tätä:

#sisältää
käyttämällä nimitilaa vakio;
float fn (float fl, int sisään)

paluu fl;

int main ()

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

Lähtö on 2.5.

Huomaa pääfunktion ensimmäinen lause, joka tekee funktiosta fn: n synonyymin. Molemmat viittaavat samaan toimintoon. Huomaa kertakäyttöinen ja. Joten & on tässä viiteoperaattori eikä operaattorin osoite. Kutsu funktio vain käyttämällä kumpaakin nimeä.

Viitetunniste ei ole sama kuin osoittimen tunniste.

Osoittimen palauttaminen

Seuraavassa ohjelmassa funktio palauttaa osoittimen, joka on teräväkohteen osoite:

#sisältää
käyttämällä nimitilaa vakio;
float * fn (float fl, int sisään)

kellua * fll = &fl;
paluu fll;

int main ()

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

Lähtö on 2.5

Funktion ensimmäinen lause fn () on vain osoitinobjektin luomiseksi. Huomaa kertakäyttöinen ja *: n sijainti toiminnon allekirjoituksessa. Huomaa myös, kuinka toinen osoitinobjekti vastaanotti osoittimen (osoitteen) main () -funktiossa.

Toiminto palauttaa viitteen

Seuraavassa ohjelmassa funktio palauttaa viitteen:

#sisältää
käyttämällä nimitilaa vakio;
float & fn (float fl, int sisään)

kellua & frr = fl;
paluu frr;

int main ()

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

Lähtö on 2.5.

Funktion ensimmäinen lause fn () on vain viitteen luomiseksi. Huomaa kertakäyttöinen ja funktion allekirjoituksen sijainti. Huomaa myös, kuinka toinen viite vastaanotti viitteen pää () -funktiossa.

Osoittimen välittäminen toiminnolle

Seuraavassa ohjelmassa osoitin, joka on oikeastaan ​​kelluvan terävän objektin osoite, lähetetään argumenttina funktiolle:

#sisältää
käyttämällä nimitilaa vakio;
float fn (float * fl, int sisään)

paluu * fl;

int main ()

kellua v = 2.5;
kelluva val = fn (& v, 6);
cout << val << '\n';
paluu 0;

Lähtö on 2.5

Huomaa kellukeparametrin * käyttö ja sijainti funktion allekirjoituksessa. Heti kun fn () -funktion arviointi alkaa, tehdään seuraava lausunto:

kellua * fl = & v;

Sekä fl että & v osoittavat samaa terävää esinettä, joka pitää 2.5. * fl palautuslausekkeessa ei ole ilmoitus; se tarkoittaa osoitetun objektin arvoa, johon osoitinobjekti osoittaa.

Toiminnon viitteen välittäminen

Seuraavassa ohjelmassa viite lähetetään argumenttina funktiolle:

#sisältää
käyttämällä nimitilaa vakio;
float fn (float & fl, int sisään)

paluu fl;

int main ()

kellua v = 2.5;
kelluva val = fn (v, 6);
cout << val << '\n';
paluu 0;

Lähtö on 2.5

Huomaa kelluvan parametrin käyttö ja sijainti funktion allekirjoituksessa. Heti kun fn () -funktion arviointi alkaa, tehdään seuraava lausunto:

kellua & fl = v;

Matriisin välittäminen funktiolle

Seuraava ohjelma näyttää, kuinka taulukko välitetään toiminnolle:

#sisältää
käyttämällä nimitilaa vakio;
int fn (int arra [])

paluu arra [2];

int main ()

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

Tuotos on 200.

Tässä ohjelmassa se on matriisi, joka välitetään. Huomaa, että funktion allekirjoituksen parametrilla on tyhjä taulukkoilmoitus. Funktion kutsun argumentti on vain luodun taulukon nimi.

Voiko C ++ -toiminto palauttaa matriisin?

Funktio C ++: ssa voi palauttaa matriisin arvon, mutta ei palauttaa taulukkoa. Seuraavan ohjelman kokoaminen johtaa virheilmoitukseen:

#sisältää
käyttämällä nimitilaa vakio;
int fn (int arra [])

palata arra;

int main ()

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

Osoittimen osoitin

Osoitin voi osoittaa toiseen osoittimeen. Eli osoitinobjektilla voi olla toisen osoitinobjektin osoite. Niiden kaikkien on silti oltava saman tyyppisiä. Seuraava koodisegmentti kuvaa tätä:

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

Lähtö on 5.

Osoitin-osoitin-ilmoituksessa käytetään kaksinkertaista *. Viimeisen terävän objektin arvon palauttamiseksi käytetään edelleen kaksinkertaista *.

Joukko osoittimia

Seuraava ohjelma näyttää, kuinka koodataan joukko osoittimia:

#sisältää
käyttämällä nimitilaa vakio;
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 [] = ei0, no1, no2, no3, no4;
cout << *arr[4] << '\n';
paluu 0;

Tuotos on:

400

Huomaa *: n käyttö ja sijainti taulukon ilmoituksessa. Huomaa *: n käyttö palauttaessasi arvoa taulukossa. Osoittimien mukana on kaksi *. Osoittimien tapauksessa yksi * on jo hoidettu, koska taulukon tunniste on osoitin.

Joukko vaihtelevan pituisia merkkijonoja

Merkkijonon kirjain on vakio, joka palauttaa osoittimen. Joukko vaihtelevan pituisia merkkijonoja on joukko osoittimia. Jokainen taulukon arvo on osoitin. Osoittimet ovat osoitteita muistipaikkoihin ja ovat samankokoisia. Eri pituiset merkkijonot ovat muualla muistissa, ei taulukossa. Seuraava ohjelma kuvaa käyttöä:

#sisältää
käyttämällä nimitilaa vakio;
int main ()

const char * arr [] = "nainen", "poika", "tyttö", "aikuinen";
cout << arr[2] << '\n';
paluu 0;

Tuotos on "tyttö".

Taulukon julistus alkaa varatulla sanalla "const" vakiolle; jota seuraa merkin “char”, sitten tähti *, joka osoittaa, että jokainen elementti on osoitin. Merkkijonon palauttamiseksi taulukosta * ei käytetä kunkin merkkijonon osoittimen implisiittisen luonteen vuoksi. Jos käytetään *, merkkijonon ensimmäinen elementti palautetaan.

Osoitin toiminnolle, joka palauttaa osoittimen

Seuraava ohjelma kuvaa kuinka osoitin palauttavan toiminnon osoitin koodataan:

#sisältää
käyttämällä nimitilaa vakio;
int * fn ()

int numero = 4;
int * inter = #
paluu inter;

int main ()

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

Lähtö on 4.

Osoittimen ilmoittaminen funktiolle, joka palauttaa osoittimen, on samanlainen kuin osoittimen ilmoitus tavalliselle funktiolle, mutta sitä edeltää tähti. Main () -funktion ensimmäinen lause kuvaa tätä. Jos haluat kutsua funktion osoittimen avulla, edeltää sitä merkillä *.

Johtopäätös

Jos haluat luoda osoittimen skalaariin, tee jotain,

kelluva terävä;
kellua * osoitin = &pointed;

* on kaksi merkitystä: ilmoituksessa se osoittaa osoittimen; palauttaa jotain, se on tähdennetyn kohteen arvo.

Taulukon nimi on vakioosoitin taulukon ensimmäiseen elementtiin.

Voit luoda osoittimen funktiolle tekemällä sen,

int (* func) () = &fn;

missä fn () on muualla määritelty funktio ja funktio on osoitin.

& on kaksi merkitystä: ilmoituksessa se osoittaa viittauksen (synonyymi) samaan objektiin kuin toinen tunniste; kun palautat jotain, se tarkoittaa osoitetta.

Voit luoda viitteen funktioon tekemällä sen,

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

missä fn () on muualla määritelty funktio ja refFunc on viite.

Kun funktio palauttaa osoittimen, osoittimen on vastaanotettava palautettu arvo. Kun funktio palauttaa viitteen, palautetun arvon on oltava vastaanotettu viitteellä.

Kun osoitin siirretään funktiolle, parametri on ilmoitus, kun taas argumentti on terävän objektin osoite. Kun välitetään viite funktiolle, parametri on ilmoitus, kun taas argumentti on viite.

Kun siirretään taulukko funktiolle, parametri on ilmoitus, kun taas argumentti on taulukon nimi ilman []. C ++ -toiminto ei palauta matriisia.

Osoitin-osoitin tarvitsee tarvittaessa kaksi * yhden sijasta.

Chrys

Asenna uusin Dolphin Emulator for Gamecube & Wii Linuxiin
Dolphin-emulaattorin avulla voit pelata valitsemiasi Gamecube & Wii -pelejä Linux-henkilökohtaisilla tietokoneilla (PC). Koska Dolphin Emulator on va...
Kuinka käyttää GameConqueror-huijausmoottoria Linuxissa
Artikkelissa on opas GameConqueror-huijausmoottorin käytöstä Linuxissa. Monet Windows-pelejä pelaavat käyttäjät käyttävät "Cheat Engine" -sovellusta m...
Parhaat pelikonsoliemulaattorit Linuxille
Tässä artikkelissa luetellaan suositut pelikonsolin emulointiohjelmistot, jotka ovat saatavana Linuxille. Emulointi on ohjelmistojen yhteensopivuusker...