* vs ** pointer i C

I denne artikel har vi forklaret forskellen mellem * og ** pointer i C og C++.

Indholdsfortegnelse:

1. Hvad er pointere?

2. Eksempler på Pointer

3. Implementering af pointere ved hjælp af C

4. *p vs **p markør

5. Implementering af *p og **p ved hjælp af C

Hvad er pointere?

Pointer er en variabel, der bruges til at gemme adressen i en anden variabels hukommelse.
De to operatorer, der bruges i pointerne:

• Operator &:- Giver adressen på en variabel
• Operator * :- Giver værdierne på stedet

Nogle point:

• Adressen må ikke være negativ.
• Pegervariabel tager samme bytes i hukommelsen uanset dens datatype.
• Pegerens variable størrelse varierer fra system til system afhængigt af operativsystemet.
• Pegervariabel kan dereferencenr. bytes afhængigt af dens datatype.
  * Heltalsmarkør kan dereference to bytes data.
  * Tegnmarkøren kan få adgang til én byte data.
  * Float pointer kan få adgang til fire bytes data.
• Pegervariabel vil blive erklæret ved at bruge '*'(stjerne).

Eksempler på markør:

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

Her erklærer og tildeler vi hukommelsesblok 'a' til en pointer 'p'.

• 'p' er pointervariablen af ​​typen heltal, hvor vi kan gemme adressen på enhver heltalsvariabel.
• 'a' er en heltalsvariabel, der gemmer værdien 10.

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

Her ser vi en fejl, fordi vi forsøger at gemme adressen på et heltal 'a' i et andet heltal 'b'

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

Her udskriver vi værdien af ​​'a' ved at repræsentere den som en pointer. Sig blot a=``*&a .

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

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

Her ser vi en FEJL, fordi 'a' har en værdi(=10) og *p har også en værdi(=10), men compileren vil blive forvirret, hvad vil vi gøre, fordi compileren ser det som printf(" %d ", (a) (*p ) ); , er der ingen aritmetiske operatorer til compiler.
Men i næste printf()-sætning ser vi ingen FEJL, fordi Now-kompileren vil give output som 100, mens vi udfører multiplikation af 'a' og *p og de indeholder begge værdi(=10) i dem.

Implementering af pointere ved hjælp af 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;
}

Her udskriver vi værdien af ​​'a' og adressen på 'a' og 'p'.

Output:

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

*p vs **p markør

*p er en pointer, betyder, at den har en adresse på en værdi eller en blok af reserveret hukommelse, den kan få adgang til op til et niveau.
Det bruges, hvis du vil beholde en hukommelsesblok, hvor dine værdier er i.

**p er en pegepind til en pegepind, betyder, at den har en adresse, der indeholder en adresse med en værdi eller en blok af reserveret hukommelse. Den kan få adgang til op til to niveauer.
Den bruges, hvis du vil sende en pointer, der får sin hukommelse allokeret i en anden 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;
  }

Her udskriver vi værdierne og adresserne ved hjælp af en pointer og en dobbelt pointer.

Output:

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 af *p og **p ved hjælp af 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;
}

Her bytter vi to tal ved hjælp af pointere.
Mens vi kalder funktionen swap(), sender vi adresserne på hukommelsesblokke (dvs. a, b), og for at tage disse adresser tager vi heltal pointere som argumenter i swap() (dvs. x, y).
I funktionen swap() bytter vi værdierne på adresserne.

Output:

 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;
}

Her tager vi først et heltal 'a' og tildeler værdien 10 til det,
derefter tage en heltalsmarkør 'p' og tildele adressen på 'a' til 'p'.
Nu i funktionskald func(), giver vi adressen på 'p', som er en pointer, for at tage adressen på en pointer, skal funktion func() have en heltalsmarkør til en pointer som et argument (dvs. p1 i func (p1)).
I func() ændrer vi værdien fra 10 til 2.

Output:

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

Med denne artikel på OpenGenus skal du have den fulde idé om * vs ** pointer i C.