* vs ** pointeur en C

Dans cet article, nous avons expliqué la différence entre les pointeurs * et ** en C et C++.

Table des matières :

1. Que sont les pointeurs ?

2. Exemples de pointeur

3. Implémentation de pointeurs en C

4. *p contre **p pointeur

5. Implémentation de *p et **p en utilisant C

Que sont les pointeurs ?

Le pointeur est une variable utilisée pour stocker l'adresse en mémoire d'une autre variable.
Les deux opérateurs utilisés dans les pointeurs :

• Opérateur &:- Donne l'adresse d'une variable
• Opérateur * :- Donne les valeurs à l'emplacement

Quelques points :

• L'adresse ne peut pas être négative.
• La variable de pointeur prend les mêmes octets de mémoire quel que soit son type de données.
• La taille de la variable de pointeur diffère d'un système à l'autre en fonction du système d'exploitation.
• La variable de pointeur peut déréférencer no. d'octets en fonction de son type de données.
  * Le pointeur entier peut déréférencer deux octets de données.
  * Le pointeur de caractère peut accéder à un octet de données.
  * Le pointeur flottant peut accéder à quatre octets de données.
• La variable de pointeur sera déclarée en utilisant '*' (astérisque).

Exemples de pointeur :

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

Ici, nous déclarons et affectons le bloc mémoire 'a' à un pointeur 'p'.

• ‘p’ est la variable pointeur de type entier où nous pouvons stocker l'adresse de n'importe quelle variable entière.
• ‘a’ est une variable entière stockant la valeur 10.

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

Ici nous voyons une erreur car nous essayons de stocker l'adresse d'un entier 'a' dans un autre entier 'b'

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

Ici, nous imprimons la valeur de 'a' en la représentant comme un pointeur. Dites simplement a=``*&a .

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

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

Ici, nous voyons une ERREUR, car 'a' a une valeur (=10) et *p a également une valeur (=10) mais le compilateur ne comprendra pas ce que nous voulons faire car le compilateur le voit comme printf(" %d ", (a) (*p ) ); , il n'y a pas d'opérateurs arithmétiques pour le compilateur.
Mais dans la prochaine instruction printf(), nous ne voyons aucune ERREUR car maintenant le compilateur donnera une sortie de 100 comme nous le faisons Multiplication de 'a' et *p et ils contiennent tous les deux value(=10).

Implémentation de pointeurs en 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;
}

Ici, nous imprimons la valeur de 'a' et l'adresse de 'a' et 'p'.

Sortie :

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

*p contre **p pointeur

*p est un pointeur, signifie qu'il contient une adresse d'une valeur ou un bloc de mémoire réservée, il peut accéder jusqu'à un niveau.
Il est utilisé si vous souhaitez conserver un bloc de mémoire où se trouvent vos valeurs.

**p est un pointeur vers un pointeur, signifie qu'il contient une adresse qui contient une adresse d'une valeur ou un bloc de mémoire réservée, il peut accéder à deux niveaux.
Il est utilisé si vous souhaitez passer un pointeur dont la mémoire est allouée dans une fonction différente.

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

Ici, nous imprimons les valeurs et les adresses à l'aide d'un pointeur et d'un double pointeur.

Sortie :

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

Implémentation de *p et **p en utilisant 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;
}

Nous voici Échangeant deux numéros à l'aide de pointeurs.
Lors de l'appel de la fonction swap(), nous envoyons les adresses des blocs de mémoire (c'est-à-dire a, b) et pour prendre ces adresses, nous prenons des pointeurs entiers comme arguments dans swap() (c'est-à-dire x, y).
Dans la fonction swap(), nous échangeons les valeurs sur les adresses.

Sortie :

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

Ici, nous prenons d'abord un entier 'a' et lui attribuons la valeur 10,
puis en prenant un pointeur entier 'p' et en attribuant l'adresse de 'a' à 'p'.
Maintenant, dans l'appel de fonction func(), nous donnons l'adresse de 'p' qui est un pointeur, pour prendre l'adresse d'un pointeur, la fonction func() doit avoir un pointeur entier vers un pointeur comme argument (c'est-à-dire p1 dans func (p1) ).
Dans func(), nous changeons la valeur de 10 à 2.

Sortie :

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

Avec cet article sur OpenGenus, vous devez avoir une idée complète du pointeur * vs ** en C.