Discussion :

[wallace27]

Bonjour,

Voici mon code :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <time.h>
#include <string.h>
#define max 10
 
 
int main (){
	/* adresse d'un pointeur */
	int variable;
	int *ptr;
	int **ptrDePtr;
	ptr = &variable;
	ptrDePtr = &ptr;
	variable = 17;
	printf("Adresse de la variable pointee : %p\n", &variable);
	printf("Adresse du pointeur : %p\n", ptr);
	printf("Adresse du pointeur de pointeur avec un asterisque : %p\n", *ptrDePtr);
	printf("Adresse du pointeur de pointeur sans asterisque : %p\n", ptrDePtr);
	return (0);
}

Et voici le résultat à l'exécution :


Adresse de la variable pointee : 0x7fff8b6024bc
Adresse du pointeur : 0x7fff8b6024bc
Adresse du pointeur de pointeur avec un asterisque : 0x7fff8b6024bc
Adresse du pointeur de pointeur sans asterisque : 0x7fff8b6024c0
[Finished in 0.0s]

Question :

Pourquoi est-ce que l'adresse du pointeur de pointeur sans astérisque dans le printf est différente de l'adresse 0x7fff8b6024bc initialement obtenue à trois reprises ?

[Obsidian]

Bonjour,

Justement parce que ce n'est pas la même variable. Quand tu utilises « * », tu déréférences le pointeur, c'est-à-dire que tu indiques au compilateur que tu ne t'intéresses plus au pointeur lui-même mais à ce qu'il pointe.

Par conséquent, une fois tous tes pointeurs dûment initialisés comme tu l'as fait, l'expression « *ptrDePtr » (avec astérisque) renvoie la même chose que « ptr » (sans astérisque). Si tu omets l'astérisque dans la première expression, tu obtiens le contenu de ptrDePtr, à savoir l'adresse de ptr et plus celle de variable.

[wallace27]

Merci pour la réponse, et comment pourrais-je obtenir l'adresse de ptr en utilisant ptr lui-même dans mon printf ?

[Invité]

De la même façon qu'un pointeur "normal", en utilisant & devant ta variable.

[Obsidian]

Exactement de la même façon que tu l'as fait pour « variable » à la première ligne.

De ce côté, les pointeurs sont des variables ordinaires : elles fonctionnent comme les autres, en précisant bien que le type de leur contenu est une adresse mémoire, et non un entier, un caractère, ou autre…

[wallace27]

Est-ce qu'une adresse mémoire n'est de toute façon un entier ?

[wallace27]

Est-ce que ce code résume bien toute notre théorie ?

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
int main (){
	int variable;
	int *ptr;
	int **ptrDePtr;
	ptr = &variable;
	ptrDePtr = &ptr;
	variable = 2;
	printf("Voici l adresse du pointeur %p\n", &ptr);
	printf("Voici l adresse du pointeur de pointeur : %p\n", &ptrDePtr);
	printf("Voici l adresse du pointeur affichee via le pointeur de pointeur : %p\n", ptrDePtr);
	printf("Voici l adresse de la variable %p\n", &variable);
	printf("Voici l adresse pointee par le pointeur %p\n", ptr);
	printf("Voici l adresse pointee par le pointeur de pointeur : %p\n", *ptrDePtr);
	return 0;
}

Résultat du code :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
Voici l adresse du pointeur 0x7fffd8069610
Voici l adresse du pointeur de pointeur : 0x7fffd8069618
Voici l adresse du pointeur affichee via le pointeur de pointeur : 0x7fffd8069610
Voici l adresse de la variable 0x7fffd806960c
Voici l adresse pointee par le pointeur 0x7fffd806960c
Voici l adresse pointee par le pointeur de pointeur : 0x7fffd806960c
[Finished in 0.0s]

Nous voyons que les deux premiers résultats, à savoir l'adresse du pointeur et l'adresse du pointeur de pointeurs sont différents des trois derniers résultats qui eux sont égaux. En effet, l'adresse de la variable, l'adresse pointée par le pointeur qui pointe vers cette variable et l'adresse pointée in fine par le pointeur de pointeur qui pointe vers l'adresse pointée par le pointeur sont les trois fois la même adresse.

[Obsidian]

Est-ce qu'une adresse mémoire n'est de toute façon un entier ?

Techniquement oui, et certains langages (comme le BASIC du temps de PEEK et POKE) utilisait effectivement un type « entier » pour représenter leurs adresses mémoire.

Cependant, le C définit un type « pointeur » explicitement pour plusieurs raisons :

• Ça permet d'indiquer que quelque chose est pointé par cette adresse et, de là, de déréférencer le pointeur avec « * » pour accéder à cet objet ;
• Ça permet également d'utiliser directement l'opérateur « [ ] » pour l'indexer comme s'il s'agissait d'un tableau ;
• Une arithmétique spéciale est employée quand tu utilises les opérateurs + et - : l'adresse n'est pas modifiée d'une unité mais de la taille de l'objet pointé ;
• Ça permet enfin au compilateur d'utiliser des entiers de la taille des adresses mémoire qui correspondent à ton micro-processeur. Par exemple, à voir les résultats que tu nous présentes, on peut en conclure que tu travailles en 64 bits.

Est-ce que ce code résume bien toute notre théorie ?

Oui.

[wallace27]

C'est avec la notion de contenu d'un pointeur que j'avais un problème. Je ne savais pas qu'il pouvait "contenir" quelque chose. Je pensais qu'il ne faisait que pointer... En fait l'adresse vers laquelle il pointe constitue son contenu c'est ça ?

[Obsidian]

En fait l'adresse vers laquelle il pointe constitue son contenu c'est ça ?

Oui. À noter que comme ce contenu est en définitive un entier binaire, il peut être invalide (ne correspondre à rien de réellement existant) et est complètement indéfini à la déclaration du pointeur, tout comme l'est le contenu d'une variable ordinaire.

[wallace27]

Voici le même type d'exemple en c++ :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
int main(){
	int t[] = {4,3,2,1};
	int *p1, **p2, *pt[2];
	p1 = &t[2];
	cout << "voici le contenu de p1 : " << *p1 << endl;
	p2 = &p1;
	cout << "voici le contenu de p2 : " << **p2 << endl;
	cout << "voici l adresse de p1 : " << p1 << endl;
	cout << "voici l adresse vers laquelle pointe p2 : " << *p2 << endl;
	cout << "voici l adresse de p2 : " << p2 << endl;
	return 0;
}