Discussion :

[Sve@r]

c'est que &tab a une signification, puisque je peux faire ceci:

Code C :

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

1
2
int tab[10];
int (*pTab)[10] = &tab; //équivaudrait à int[10]* pTab = &tab;

La question n'est pas si &tab a ou n'a pas de signification (oui c'est ce que j'ai écrit dans mon dernier post mais c'était une maladresse et j'ai d'ailleurs bien précisé que ma retranscription n'était pas à l'exacte réplique des idées échangées la dernière fois qu'on avait évoqué ce sujet) mais plutôt de savoir si &tab est réellement identique à tab. Comment deux adresses identiques pourraient référencer deux objets différents qui cohabiteraient ensembles ? j'ai essayé d'afficher pTab et *pTab mais j'obtiens la même chose.

Accessoirement on peut écrire à la place int *pTab=tab et obtenir le même résultat.

On retrouve d'ailleurs la même question avec les pointeurs de fonctions

Code c :

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
#include <stdio.h>
 
void affiche(int n)
{
	printf("%d\n", n);
}
 
int main()
{
	void (*pt)(int)=affiche;
	(*pt)(5);  // Ou bien (*************pt)(5)
	printf("%p\n", pt);
	printf("%p\n", *pt);
	printf("%p\n", **pt);
	printf("%p\n", ***pt);
	printf("%p\n", ****pt);
}

On peut mettre autant d'étoiles que l'on veut dans le printf(), l'adresse affichée est toujours la même. Et on peut de la même façon mettre autant d'étoiles que l'on veut lors de l'appel du pointeur...

[diogene]

Comment deux adresses identiques pourraient référencer deux objets différents qui cohabiteraient ensembles ?

Ce n'est pas choquant, et c'est d'ailleurs le cas avec une structure et le premier champ de la structure. Il y a un rapport d'un objet à un sous-objet.
Dans le cas évoqué dans la discussion, l'objet est le tableau et le sous-objet son premier élément.

De plus, dire que les adresses sont identiques est un abus : une adresse en C n'est pas simplement un repère d'une position mémoire, c'es aussi un type et on ne peut pas dissocier les deux. Même si le repère est identique, si le type est différent alors les adresses (en C) sont différentes.

[Médinoc]

Ah, les pointeurs de fonctions sont une autre paire de manches, car là on tombe sur des trucs qui ne veulent pas dire grand-chose en C (notamment, on a des types "pointeur de fonction" mais pas vraiment de types "fonction", d'ailleurs on ne peut pas faire d'arithmétique de pointeurs sur un pointeur de fonction alors qu'on le peut pour un pointeur de tableau).

Je pense que le coup des tableaux est assez similaire à celui des structures: Il me semble qu'il y a une garantie en C qu'un pointeur de structure pointe vers la même adresse qu'un pointeur vers son premier champ (garantie absente en C++ dès que la virtualité entre en jeu).

Edit: Diogene m'a devancé

[Sve@r]

une adresse en C n'est pas simplement un repère d'une position mémoire, c'est aussi un type et on ne peut pas dissocier les deux. Même si le repère est identique, si le type est différent alors les adresses (en C) sont différentes.

Merci de cette précision. Ce qui me donne alors une idée pour "voir" physiquement cette différence: jouer avec l'arithmétique des pointeurs (évoquée aussi par Médinoc)

Petit exemple

Code c :

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>
 
void affiche(int *tab, int n)
{
	int i;
	printf("Adresse reçue: %p\n", tab);
	for (i=0; i < n; i++)
		printf("tab[%d]=%d (%p)\n", i, tab[i], &tab[i]);
	fputc('\n', stdout);
}
 
int main()
{
	int tab[][5]={
		{5, 4, 3, 2, 1},
		{10, 8, 6, 4, 2},
	};
	int (*pt)[5]=tab;
	affiche(*pt, 5);
	pt++;
	affiche(*pt, 5);
}

Et le résultat

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
Adresse reçue: 0x7fffc0ebf5b0
tab[0]=5 (0x7fffc0ebf5b0)
tab[1]=4 (0x7fffc0ebf5b4)
tab[2]=3 (0x7fffc0ebf5b8)
tab[3]=2 (0x7fffc0ebf5bc)
tab[4]=1 (0x7fffc0ebf5c0)
 
Adresse reçue: 0x7fffc0ebf5c4
tab[0]=10 (0x7fffc0ebf5c4)
tab[1]=8 (0x7fffc0ebf5c8)
tab[2]=6 (0x7fffc0ebf5cc)
tab[3]=4 (0x7fffc0ebf5d0)
tab[4]=2 (0x7fffc0ebf5d4)

Bien que les adresses soient les mêmes au départ, on voit bien que pt++ a fait avancer le pointeur de 20 octets c'est à dire d'un "tableau" de 5 entiers tandis que les sous-adresses n'avancent que de 4 octets. Et on a un résultat proportionnellement équivalent si on prend des tableaux de 6 entiers.

Merci à vous deux de vos idées