* vs ** pekare i C

I den här artikeln har vi förklarat skillnaden mellan * och ** pekare i C och C++.

Innehållsförteckning:

1. Vad är pekare?

2. Exempel på Pointer

3. Implementering av pekare med C

4. *p mot **p pekare

5. Implementering av *p och **p med C

Vad är pekare?

Pointer är en variabel som används för att lagra adressen i en annan variabels minne.
De två operatorerna som används i pekarna:

• Operator &:- Ger adressen till en variabel
• Operator * :- Ger värdena på plats

Några poäng:

• Adress kan inte vara negativ.
• Pekarvariabeln tar samma byte i minnet oavsett datatyp.
• Pekarens variabelstorlek skiljer sig från system till system beroende på operativsystem.
• Pekarvariabel kan avreferensnr. byte beroende på dess datatyp.
  * Heltalspekare kan avreferera två byte data.
  * Teckenpekaren kan komma åt en byte med data.
  * Flytpekaren kan komma åt fyra byte med data.
• Pekarvariabel kommer att deklareras med hjälp av '*'(asterisk).

Exempel på pekare:

int * p ;         // Declaration of pointer ‘p’  
int a = 10 ;  
p = &a ;          //Assigning 
                  //now pointer ‘p’ is pointing at variable ‘a’.  

Här deklarerar vi och tilldelar minnesblocket 'a' till en pekare 'p'.

• 'p' är pekarvariabeln av typen heltal där vi kan lagra adressen till vilken heltalsvariabel som helst.
• 'a' är en heltalsvariabel som lagrar värdet 10.

int * p ; 
int a = 10 , b ;  
b = &a ;          //ERROR

Här ser vi ett fel eftersom vi försöker lagra adressen till ett heltal 'a' i ett annat heltal 'b'

int a = 10 ;
printf(" a = %d " , * &a );   // output will be a = 10 

Här skriver vi ut värdet på 'a' genom att representera det som en pekare. Säg bara a=``*&a .

int * p ; 
int a = 10 ;  
p = &a ;  
printf(" %d " , a * p ) ;   // ERROR

printf(" %d " , a * * p );  // No ERROR

Här ser vi ett FEL, eftersom 'a' har ett värde (=10) och *p har också ett värde(=10) men kompilatorn kommer att bli förvirrad vad vill vi göra eftersom kompilatorn ser det som printf(" %d ", (a) (*p ) ); , det finns inga aritmetiska operatorer för kompilatorn.
Men i nästa printf()-sats ser vi inget FEL eftersom Now-kompilatorn ger utdata som 100 när vi gör Multiplikation av 'a' och *p och de båda innehåller värde(=10) i dem.

Implementering av pekare med C

#include<stdio.h>
int main(){
  int a=10;
  int * p = &a ;
  printf("  a = %d \n " , * p ) ;   // It gives output a = 10
  printf(" Address of a = %p \n ", p ) ;  // It gives output Address of a
  printf(" Address of p = %p \n ", & p ) ; // It gives output Address of p
return 0;
}

Här skriver vi ut värdet på 'a' och adressen på 'a' och 'p'.

Utdata:

  a = 10
  Address of a = 000000000061FE1C
  Address of p = 000000000061FE10

*p kontra **p pekare

*p är en pekare, betyder att den innehåller en adress med ett värde eller ett block av reserverat minne. Den kan komma åt upp till en nivå.
Den används om du vill behålla ett minnesblock där dina värden finns.

**p är en pekare till en pekare, betyder att den innehåller en adress som innehåller en adress med ett värde eller ett block av reserverat minne. Den kan komma åt upp till två nivåer.
Den används om du vill skicka en pekare som får sitt minne tilldelat i en annan funktion.

  #include<stdio.h>
  int main(){
  int a=10;
  int * p = & a ;              // b is a single pointer or a pointer
  int ** c = &p;         // c is a double pointer or pointer to a pointer 
  printf("using p \n ");
  printf(" value of a = %d \n " , * p ) ;  // It gives output value of a = 10
  printf(" Address of a = %p \n ", p ) ;    // It gives output Address of a
  printf(" Address of p = %p \n", & p ) ;  // It gives output Address of p
  printf("using c \n ");
  printf(" value of a = %d \n ", ** c ) ;    //  It gives output value of a
  printf(" Address of a = %p \n ", * c ) ;   // It gives output Address of a
  printf(" Address of c = %p \n ", &c ) ;   // It gives output Address of c
  printf(" Address of p = %p \n ",  c ) ;   // It gives output Address of p
  return 0;
  }

Här skriver vi ut värdena och adresserna med hjälp av en pekare och en dubbelpekare.

Utdata:

using p
value of a = 10
Address of a = 000000000061FE1C
Address of p = 000000000061FE10
using c
value of a = 10
Address of a = 000000000061FE1C
Address of c = 000000000061FE08
Address of p = 000000000061FE10

Implementering av *p och **p med C

#include<stdio.h>
void swap(int * x ,int * y ){
int t = * x ;
 * x = * y ;
 * y = t ;
}
int main(){
  int a = 10 , b = 20 ;
  printf(" Value of 'a' before swap = %d \n", a );
  printf(" Value of 'b' before swap = %d \n", b );

  swap( & a , & b ) ;         //function call
  
  printf(" Value of 'a' after swap = %d \n", a );
  printf(" Value of 'b' after swap = %d \n", b );

return 0;
}

Här byter vi två nummer med hjälp av pekare.
När vi anropar funktionen swap() skickar vi adresserna till minnesblock (dvs a, b) och för att ta dessa adresser tar vi heltalspekare som argument i swap() (dvs x, y).
I funktionen swap() byter vi ut värdena på adresserna.

Utdata:

 Value of 'a' before swap = 10
 Value of 'b' before swap = 20
 Value of 'a' after swap = 20
 Value of 'b' after swap = 10

#include<stdio.h>

void func(int ** p1 )
{
    int b = 2;
    * p1 = & b;
}

int main()
{
    int a = 10;
    int * p = &a;
    printf("Before the function, value of the p : %d \n", * p) ;
    func(&p);    //function Call
    printf("After the function, new value of the p : %d \n", * p) ;

return 0;
}

Här tar vi först ett heltal 'a' och tilldelar det värdet 10,
tar sedan en heltalspekare 'p' och tilldelar adressen för 'a' till 'p'.
Nu i funktionsanrop func(), ger vi adressen till 'p' som är en pekare, för att ta adressen till en pekare, bör funktion func() ha en heltalspekare till en pekare som ett argument (dvs. p1 i func (pl)).
I func() ändrar vi värdet från 10 till 2.

Utdata:

Before the function, value of the p : 10
After the function, new value of the p : 2

Med den här artikeln på OpenGenus måste du ha den fullständiga idén om * vs ** pekare i C.