C-osoittimet (esimerkkien kanssa)

Tässä opetusohjelmassa opit viitteistä; mitä viitteitä on, miten käytät niitä ja yleisiä virheitä, joita saatat kohdata työskennellessäsi niiden kanssa esimerkkien avulla.

Osoittimet ovat tehokkaita ominaisuuksia C- ja C ++ -ohjelmoinnissa. Ennen kuin opimme osoittimia, tutustutaan osoitteisiin C-ohjelmoinnissa.

Osoite kohdassa C

Jos ohjelmassasi on muuttuja var, &varanna sen osoite muistissa.

Olemme käyttäneet osoitetta useita kertoja scanf()toiminnon käytön aikana.

 scanf("%d", &var);

Tässä käyttäjän syöttämä arvo tallennetaan muuttujan muuttujan osoitteeseen. Otetaan toimiva esimerkki.

 #include int main() ( int var = 5; printf("var: %d", var); // Notice the use of & before var printf("address of var: %p", &var); return 0; )

Tuotos

 var: 5: n var: 2686778 osoite

Huomaa: Saat todennäköisesti toisen osoitteen, kun suoritat yllä olevan koodin.

C Osoittimet

Osoittimet (osoitinmuuttujat) ovat erityisiä muuttujia, joita käytetään osoitteiden tallentamiseen arvojen sijaan.

Osoittimen syntakse

Näin voimme julistaa viitteitä.

 int* p;

Tässä olemme ilmoittaneet osoittimen p inttyypiksi.

Voit myös ilmoittaa osoittimet näillä tavoilla.

 int *p1; int * p2;

Otetaan toinen esimerkki osoittimien ilmoittamisesta.

 int* p1, p2;

Tässä olemme ilmoittaneet osoittimen p1 ja normaalin muuttujan p2.

Osoitteiden osoittaminen osoittimille

Otetaan esimerkki.

 int* pc, c; c = 5; pc = &c;

Tässä 5 on määritetty muuttujalle c. Ja c: n osoite osoitetaan pc-osoittimelle.

Hanki osoittimen osoittaman arvon arvo

Saadaksesi osoittimen osoittaman asian arvon käytämme *operaattoria. Esimerkiksi:

 int* pc, c; c = 5; pc = &c; printf("%d", *pc); // Output: 5

Tässä osoite cosoitetaan pc-osoittimelle. Saadaksesi tähän osoitteeseen tallennetun arvon käytimme * pc: tä.

Huomaa: Yllä olevassa esimerkissä pc on osoitin, ei *pc. Et voi eikä sinun pitäisi tehdä jotain sellaista *pc = &c;

Muuten, *sitä kutsutaan poikkeamaoperaattoriksi (työskenneltäessä osoittimien kanssa). Se toimii osoittimella ja antaa kyseiseen osoittimeen tallennetun arvon.

Osoittimien osoittama arvon muuttaminen

Otetaan esimerkki.

 int* pc, c; c = 5; pc = &c; c = 1; printf("%d", c); // Output: 1 printf("%d", *pc); // Ouptut: 1

Olemme osoittaneet c-osoitteen PC-osoittimeen.

Sitten muutimme c: n arvon arvoksi 1. Koska pc ja c: n osoite ovat samat, *pcsaadaan meille 1.

Otetaan toinen esimerkki.

 int* pc, c; c = 5; pc = &c; *pc = 1; printf("%d", *pc); // Ouptut: 1 printf("%d", c); // Output: 1

Olemme osoittaneet c-osoitteen PC-osoittimeen.

Sitten muutimme *pc1: ksi *pc = 1;. Koska pc ja c: n osoite ovat samat, c on yhtä suuri kuin 1.

Otetaan vielä yksi esimerkki.

 int* pc, c, d; c = 5; d = -15; pc = &c; printf("%d", *pc); // Output: 5 pc = &d; printf("%d", *pc); // Ouptut: -15

Aluksi c: n osoite osoitetaan pc-osoittimelle käyttämällä pc = &c;. Koska c on 5, *pcantaa meille 5.

Sitten osoitetaan d: n osoite pc-osoittimelle käyttämällä pc = &d;. Koska d on -15, *pcantaa meille -15.

Esimerkki: Osoittimien käyttö

Otetaan toimiva esimerkki.

 #include int main() ( int* pc, c; c = 22; printf("Address of c: %p", &c); printf("Value of c: %d", c); // 22 pc = &c; printf("Address of pointer pc: %p", pc); printf("Content of pointer pc: %d", *pc); // 22 c = 11; printf("Address of pointer pc: %p", pc); printf("Content of pointer pc: %d", *pc); // 11 *pc = 2; printf("Address of c: %p", &c); printf("Value of c: %d", c); // 2 return 0; )

Tuotos

 C: n osoite: 2686784 c: n arvo: 22 Osoitin-pc: n osoite: 2686784 Osoitin-pc: n sisältö: 22 Osoitin-pc: n osoite: 2686784 Osoitin-pc: n sisältö: 11 Osoitteen pc: 2686784 c: n arvo: 2

Ohjelman selitys

  1. int* pc, c;

    Here, a pointer pc and a normal variable c, both of type int, is created.
    Since pc and c are not initialized at initially, pointer pc points to either no address or a random address. And, variable c has an address but contains random garbage value.
  2. c = 22;

    This assigns 22 to the variable c. That is, 22 is stored in the memory location of variable c.
  3. pc = &c;

    This assigns the address of variable c to the pointer pc.
  4. c = 11;

    This assigns 11 to variable c.
  5. *pc = 2;

    This change the value at the memory location pointed by the pointer pc to 2.

Common mistakes when working with pointers

Suppose, you want pointer pc to point to the address of c. Then,

 int c, *pc; // pc is address but c is not pc = c; // Error // &c is address but *pc is not *pc = &c; // Error // both &c and pc are addresses pc = &c; // both c and *pc values *pc = c;

Here's an example of pointer syntax beginners often find confusing.

 #include int main() ( int c = 5; int *p = &c; printf("%d", *p); // 5 return 0; )

Why didn't we get an error when using int *p = &c;?

It's because

 int *p = &c;

is equivalent to

 int *p: p = &c;

Molemmissa tapauksissa luomme osoittimen p(ei *p) ja osoitamme &csen.

Tämän sekaannuksen välttämiseksi voimme käyttää lausetta näin:

 int* p = &c;

Nyt tiedät mitä osoittimet ovat, opit seuraavassa opetusohjelmassa kuinka osoittimet liittyvät matriiseihin.

Mielenkiintoisia artikkeleita...