Pointeurs en C

在本教程中，您将学习指针。什么是指针，如何使用它们以及在示例的帮助下使用它们时可能遇到的常见错误。

指针是 C和C ++ 编程的强大功能。在学习指针之前，让我们学习一下C语言编程中的地址。

C 语言地址

如果程序中有变量var，则＆var将在内存中提供其地址。

使用scanf()函数时，我们已多次使用地址。

scanf("%d",　&var);

在此，用户输入的值存储在var变量的地址中。让我们举一个可行的实例。

#include <stdio.h>
int main()
{
　　int　var　=　5;
　　printf("var:　%d\n",　var);
　　//　注意在var之前使用＆
　　printf("address　of　var:　%p",　&var);　　
　　return 0;
}

résultat de la sortie

var：　5　
var地址：　2686778

注意：运行上面的代码时，您可能会获得其他地址。

Pointeurs en C

指针（指针变量）是用于存储地址而非值的特殊变量。

指针语法

这是我们声明指针的方法。

int*　p;

在这里，我们已经声明了一个int类型的指针p。

您也可以通过以下方式声明指针。

int　*p1;
int　*　p2;

让我们再举一个声明指针的实例。

int*　p1,　p2;

在这里，我们声明了一个指针p1和一个普通变量p2.

给指针分配地址

Laissons-nous prendre un exemple.

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

在此，将5分配给c变量。并且，将c的地址分配给pc指针。

获取指针所指向的值

为了获取指针所指向的内容的值，我们使用了解引用运算符（*）。例：

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

ici, l'adresse de c a été allouée au pointeur pc. Pour obtenir la valeur stockée à cette adresse, nous avons utilisé*pc.

changer la valeur pointée par le pointeur

Laissons-nous prendre un exemple.

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

nous avons déjà alloué l'adresse de c au pointeur pc.

ensuite, nous changeons la valeur de1. Comme les adresses de pc et c sont les mêmes, donc*pc obtient1.

Laissons-nous prendre un autre exemple.

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

nous avons déjà alloué l'adresse de c au pointeur pc.

ensuite, nous utilisons* pc = 1; allouer* pc est modifié1. Comme les adresses de pc et c sont les mêmes, donc c est égal à1.

Laissons-nous prendre un autre exemple.

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

initialement, l'adresse allouée à c est allouée au pointeur pc = &c; . Comme c est5donc*pc nous5.

ensuite, utilisez l'adresse d'allouée à l'adresse du pointeur pc = &d; . Comme d est-15donc*pc nous-15.

Exemple: comment fonctionne un pointeur

Laissons nous prendre un exemple viable.

#include <stdio.h>
int main()
{
　　　int*　pc, c;
　　　
　　　c =　22;
　　　printf("adresse de c: %p\n", &c);
　　　printf("valeur de c: %d\n\n", c);　　//　22
　　　
　　　pc = &c;
　　　printf("adresse du pointeur pc: %p\n", pc);
　　　printf("contenu du pointeur pc: %d\n\n",　*pc);　//　22
　　　
　　　c =　11;
　　　printf("adresse du pointeur pc: %p\n", pc);
　　　printf("contenu du pointeur pc: %d\n\n",　*pc);　//　11
　　　
　　　*pc =　2;
　　　printf("adresse de c: %p\n", &c);
　　　printf("valeur de c: %d\n\n", c);　//　2
　　　return 0;
}

résultat de la sortie

adresse de c: 003FFBF8
valeur de c:　22
adresse du pointeur pc: 003FFBF8
contenu du pointeur pc:　22
adresse du pointeur pc: 003FFBF8
contenu du pointeur pc:　11
adresse de c: 003FFBF8
valeur de c:　2

l'utilisation du programme

1. int* pc, c;
   
   ici, un pointeur pc et une variable ordinaire c ont été créés, tous deux de type int. Comme pc et c n'ont pas été initialisés à l'origine, le pointeur pc pointe vers une adresse non allouée ou une adresse aléatoire. La variable c a une adresse, mais contient des valeurs garbage aléatoires. 　

2. c = 22;
   
   c'est l'affectation d'une valeur à la variable c22autrement dit,22est stockée dans la mémoire de la variable c.
   　

3. pc = &c;
   
   ceci alloue l'adresse de la variable c à l'adresse du pointeur pc.
   　

4. c = 11;
   
   ceci11allouée à la variable c.
   　

5. *pc = 2;
   
   ceci changera la valeur de la position mémoire pointée par le pointeur pc2.

erreurs courantes lors de l'utilisation des pointeurs

hypothétiquement, vous souhaitez que le pointeur pc pointe vers l'adresse de c. Puis,

int c,　*pc;
//pc est une adresse, mais c n'est pas
pc = c;　//　Erreur
//＆c est une adresse, mais*　pc n'est pas
*pc = &c;　//　Erreur
//＆c et pc sont des adresses
pc = &c;
//c et*valeur de pc
*pc = c;

C'est un exemple qui peut souvent prêter à confusion pour les débutants en syntaxe des pointeurs.

#include <stdio.h>
int main() {
　　　int c =　5;
　　　int　*p　=　&c;
　　　printf("%d",　*p);　　//　5
　　　return 0;　
}

Pourquoi n'y a-t-il pas d'erreur lors de l'utilisation int　*p = &c;？

C'est parce que

int　*p　=　&c;

est équivalent à

int　*p:
p　=　&c;

Dans ces deux cas, nous avons créé un pointeur p (pas*(p) et lui attribuer la valeur &c.

Pour éviter ce confusion, nous pouvons utiliser la following statement:

int*　p　=　&c;

Maintenant que vous savez ce qu'est un pointeur, vous allez apprendre dans le prochain tutoriel la relation entre les pointeurs et les tableaux.