Qu'est-ce que le pointeur en langage C ?

---

avant-propos

Alors que les pointeurs simplifient l'exécution de certaines tâches de programmation C, d'autres, telles que l'allocation dynamique de mémoire, ne peuvent pas être effectuées sans pointeurs.
Par conséquent, si vous voulez devenir un excellent programmeur C, il est nécessaire d'apprendre les pointeurs.

---

1. Qu'est-ce qu'un pointeur ?

Un pointeur est une variable qui stocke une adresse mémoire.
Cette adresse mémoire pointe vers l'emplacement d'une autre variable, permettant au programme d'accéder et de manipuler la valeur de cette variable.

Chaque variable a une adresse mémoire et l'adresse mémoire est 可用 & 运算符取到内存地址.

Les déclarations de pointeur utilisent le symbole *

// p 是一个指针变量，它存储了一个地址
// *p 是指针 p 所指向的地址上存储的值
int *p;

Dans cette instruction, la variable p est un pointeur de type entier. Vous pouvez utiliser le symbole & pour obtenir l'adresse d'une variable.

int n = 10;
int *p = &n;

Dans cette instruction, &n obtient l'adresse de la variable n et attribue l'adresse au pointeur p. Par le pointeur p, la valeur de la variable n est accessible et modifiable.

*p = 20;
printf("%d", n); // 输出20

* Dans cette instruction, p représente la valeur stockée dans l'adresse mémoire pointée par le pointeur p. Après avoir attribué *p avec une valeur de 20, la valeur de la variable n est également changée en 20.

Deuxièmement, comment utiliser le pointeur ?

Définir une variable de pointeur ;
affecter l'adresse de la variable au pointeur ;
accéder à la valeur de l'adresse disponible dans la variable de pointeur.
Celles-ci sont renvoyées en utilisant l'opérateur unaire * pour renvoyer la valeur de la variable à l'adresse spécifiée par l'opérande.

1. Opérations arithmétiques sur les pointeurs

• A chaque fois le pointeur 递增pointe sur 下一个l'unité de stockage de l'élément.
• A chaque fois le pointeur 递减pointe sur 前一个l'unité de stockage de l'élément.
• Le nombre d'octets que le pointeur saute lors de l'incrémentation et de la décrémentation dépend de 指针变量数据类型长度, par exemple, un int est de 4 octets.

incrémenter un pointeur

#include <stdio.h>

const int MAX = 3;

int main ()
{
    
    
   int  var[] = {
    
    10, 100, 200};
   int  i, *ptr;
   /* 指针中的数组地址 */
   ptr = var;
   for ( i = 0; i < MAX; i++)
   {
    
    
      printf("存储地址：var[%d] = %p\n", i, ptr );
      printf("存储值：var[%d] = %d\n", i, *ptr );
      /* 指向下一个位置 */
      ptr++;
   }
   return 0;
}
// 存储地址：var[0] = e4a298cc
// 存储值：var[0] = 10
// 存储地址：var[1] = e4a298d0
// 存储值：var[1] = 100
// 存储地址：var[2] = e4a298d4
// 存储值：var[2] = 200

Comparaison des pointeurs
Tant que l'adresse pointée par le pointeur de variable est inférieure ou égale à l'adresse &var[MAX - 1] du dernier élément du tableau, le pointeur de variable est incrémenté.

#include <stdio.h>
 
const int MAX = 3;
 
int main ()
{
    
    
   int  var[] = {
    
    10, 100, 200};
   int  i, *ptr;
 
   /* 指针中第一个元素的地址*/
   ptr = &var;
   i = 0;
   while ( ptr <= &var[MAX - 1] )
   {
    
    
      printf("存储地址：var[%d] = %p\n", i, ptr );
      printf("存储值：var[%d] = %d\n", i, *ptr );
 
      /* 指向下一个位置 */
      ptr++;
      i++;
   }
   return 0;
}

2. Tableau de pointeurs

ptr est déclaré comme un tableau composé de MAX pointeurs entiers.
Par conséquent, chaque élément de ptr est un pointeur vers une valeur int.

int *ptr[MAX];

L'exemple suivant utilise trois entiers, qui seront stockés dans un tableau de pointeurs, comme suit :

#include <stdio.h>
 
const int MAX = 3;
 
int main ()
{
    
    
   int  var[] = {
    
    10, 100, 200};
   int i, *ptr[MAX];
 
   for ( i = 0; i < MAX; i++)
   {
    
    
      ptr[i] = &var[i]; /* 赋值为整数的地址 */
   }
   return 0;
}

3. Pointeur à pointeur

Un pointeur vers un pointeur est une forme d'indirection à plusieurs niveaux. Lorsque nous définissons un pointeur sur pointeur, le premier pointeur contient l'adresse du deuxième pointeur, qui pointe vers l'emplacement contenant la valeur réelle.
Pointeur vers un pointeur de type int :

int a = 100;
int *p1 = &a;
int **p2 = &p1;

Le langage C ne limite pas le nombre de niveaux de pointeurs, pour chaque niveau supplémentaire de pointeurs, un astérisque * doit être ajouté lors de la définition des variables pointeurs.
p1 est un pointeur de premier niveau, pointant vers des données de type commun, avec un * lorsqu'il est défini ;
p2 est un pointeur de second niveau, pointant vers le pointeur de premier niveau p1, avec deux * lorsqu'il est défini.

4. Passez le pointeur à la fonction

#include <stdio.h>

void increment(int *ptr) {
    
    
    (*ptr)++;
}

int main() {
    
    
    int num = 5;
    printf("Before increment: %d\n", num);
    increment(&num);
    printf("After increment: %d\n", num);
    return 0;
}

5. Pointeur de retour de la fonction

// todo

---