Quelle est la différence entre un pointeur et une variable de pointeur?

Je sais que c‘est très basique, mais c’est un peu déroutant pour moi.
J’ai lu:

un pointeur n’est rien d’autre qu’une adresse et une variable de pointeur est simplement une variable pouvant stocker une adresse .
Lorsque nous stockons l’adresse d’une variable i dans la variable de pointeur p , nous disons que p pointe sur i .

 int i, *p = &i; 

p pointe sur i .

Pour accéder à l’object pointé par un pointeur, nous utilisons l’opérateur * (indirection).

Si p est un pointeur, alors *p représente l’object vers lequel pointe actuellement p .

Maintenant je suis confus que que devrais-je appeler ppointeur ou variable de pointeur ?

Supplémentaire: Un pointeur est-il toujours identique à une adresse?

La différence entre une valeur de pointeur et une variable de pointeur est illustrée par:

 int swap_int(int *i1, int *i2) { int t = *i1; *i1 = *i2; *i2 = t; } int main(void) { int v1 = 0; int v2 = 37; int *p2 = &v2; printf("v1 = %d, v2 = %d\n", v1, v2); swap_int(&v1, p2); printf("v1 = %d, v2 = %d\n", v1, v2); return 0; } 

Ici, p2 est une variable de pointeur; c’est un pointeur sur int . D’autre part, dans l’appel à swap_int() , l’argument &v1 est une valeur de pointeur, mais il ne s’agit en aucun cas d’une variable de pointeur (dans la fonction d’appel). C’est un pointeur sur une variable (et cette variable est v1 ), mais écrire &v1 ne crée pas une variable de pointeur. Dans la fonction appelée, la valeur du pointeur &v1 est affectée à la variable de pointeur local i1 et la valeur de la variable de pointeur p2 est affectée à la variable de pointeur local i2 , mais ce n’est pas la même chose que dire &v1 est une variable de pointeur ( parce que ce n’est pas une variable de pointeur, c’est simplement une valeur de pointeur).

Cependant, pour de nombreuses raisons, la distinction est floue. Les gens diraient que « p2 est un pointeur» et c’est assez vrai; c’est une variable de pointeur, et sa valeur est une valeur de pointeur, et *p2 est la valeur de l’object p2 par p2 . Vous obtenez le même flou avec ‘ v1 is a int ‘; c’est en fait une variable int et sa valeur est une valeur int .

Remplaçons le mot “pointeur” par un type de données qui, espérons-le, est plus connu, comme un int :

 int n = 42; 

Ici 42 est une valeur int et n est une variable qui contient un int . Vous pouvez appeler n une “variable int “. Un int est un nombre comme 42 ou -25315685, et une variable int contient ces nombres. Une fois que vous avez une variable, vous pouvez lui atsortingbuer différents nombres. Rien de déroutant jusqu’à présent?

Un pointeur est comme un int: un nombre. Il s’agit d’un numéro qui identifie un emplacement de mémoire, et si quelque chose est stocké dans cet emplacement de mémoire, vous pouvez l’appeler une adresse . Comme un int, un pointeur peut être stocké dans une variable. Une variable qui stocke un pointeur pourrait être appelée une variable de pointeur.

Alors, quelle est la différence entre un pointeur et une variable de pointeur? Le premier est une valeur, comme un nombre, le second stocke ces valeurs. Mais souvent, les gens se réfèrent aux variables par leurs valeurs qu’ils stockent; les gens n’appellent pas n une “variable int ” mais juste un int , même s’il peut stocker à différents moments des int différents. Dans ce texte, je vais faire la même chose et parfois écrire un pointeur quand je parle d’une variable de pointeur; j’espère que la distinction sera claire.

Un pointeur est-il toujours une adresse? Ceci est une question sur le sens du mot “adresse” plus que toute autre chose. Un pointeur est toujours une adresse dans le sens où il correspond à un emplacement mémoire d’une manière ou d’une autre, c’est une “adresse” pour cet emplacement mémoire. Mais d’autre part, si l’emplacement mémoire n’est pas accessible au programme ou n’y contient aucun élément utile, s’agit-il vraiment d’une «adresse»?

Examinons maintenant le code suivant:

 int *p; p = &n; 

La première ligne déclare une variable de pointeur appelée p . Les pointeurs pouvant être stockés dans p sont des emplacements de mémoire pour les données int ; c’est important pour des raisons que nous verrons plus tard. Nous ne donnons toujours aucune valeur à p , le pointeur qu’il stocke est donc arbitraire. Il ne stocke certainement l’adresse d’aucun object utile; il peut même indiquer une zone de mémoire inaccessible au programme.

Dans la deuxième ligne, prenons l’adresse de la variable n avec l’opérateur & et l’associons à p . Maintenant p stocke l’adresse de n , l’emplacement mémoire où la valeur de n est stockée.

Que pouvons-nous faire avec un pointeur? Nous pouvons lire et écrire dans l’emplacement de mémoire identifié par le pointeur. Pour ce faire, nous “déréférencons” le pointeur avec l’opérateur * , puis (*p) peut être utilisé comme vous pouvez utiliser n . Par exemple, vous pouvez écrire une nouvelle valeur dans n avec ceci:

 *p = 123; 

C’est à ce stade que nous comprenons mieux pourquoi nous devons connaître le type de données que p peut indiquer: sinon, vous ne pouvez pas savoir ce que vous pouvez affecter à (*p) .

L’ arithmétique de pointeur est une autre raison pour laquelle il est important de connaître le type de données que p peut désigner . Par exemple, p+1 est un pointeur sur l’ int enregistré dans la mémoire juste après n ; si p était un pointeur sur une grosse structure de données, p+1 serait un pointeur sur une structure de données du même type, stockée juste après. Pour cela, le compilateur doit connaître la taille de la cible.

Le jeton p est une variable de pointeur, qui pointe vers une variable i . Nous pouvons simplement appeler cela un pointeur.

Une déclaration:

 int* p; int i; p = &i; 

déclare p comme identifiant d’un object de type int . Ceci est généralement indiqué de manière plus succincte: 'p is a pointer to i' . p peut être utilisé pour faire référence à la variable int après l’expression p = &i . Pour accéder à la valeur de la variable i aide du pointeur p vous pouvez utiliser l’opérateur de déréférence * (par exemple *p ). Et i = 10; équivalent à *p = 10; .

Remarquez également dans l’expression p = &i; pour lire l’adresse de i j’ai utilisé l’opérateur & esperluette également appelé Address of operand .

Un pointeur est juste une adresse logique (un identifiant avec lequel une variable peut être référencée). La norme C ne définit pas ce qu’est un pointeur en interne ni son fonctionnement en interne.

Vous voudriez lire: Qu’est-ce qu’un pointeur C, sinon une adresse mémoire?
De plus, lisez ceci: Comprendre le but des pointeurs.

Les termes pointeur et variable de pointeur sont souvent utilisés comme synonymes.

Une variable est un endroit pour stocker une valeur. En C, chaque fois que vous utilisez une variable dans un contexte nécessitant une valeur, la valeur de la variable est extraite. Par conséquent, dire “p” dans ce contexte revient à dire “la valeur de la variable p”:

 int *q = p; // Copy the value of variable p into the variable q. // aka: copy p into q. 

pointeur: une variable dont la valeur est l’adresse d’une autre variable.

variable de pointeur: contient l’adresse ou l’adresse de la mémoire où une autre variable, valeur de données ou fonction est stockée.