Discussion :

[d-a-v-e]

kand je declare un tableau a en ecrivant
int a[10];
en fait a est le pointeur ki pointe vers le debut du tableau!
c pour koi si je met cout<<a; il m affichera l adresse du premier element du tableau.
et je peu aussi ecrire
int *b=a;
mais pkoi je ne peu pas ecrire
int**a=&a;
??????
kelkun peut m expliker?

[Laurent Gomila]

Parce que dans le cas d'un identifiant de tableau déclaré de la sorte, a et &a sont équivalents.

Et puis un identifiant de tableau n'a pas d'adresse, puisque ce n'est qu'un identifiant. La seule chose qui soit stockée en mémoire ce sont les éléments du tableau.

[diogene]

d-a-v-e :

mais pkoi je ne peu pas ecrire

Code :

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

1
2
3
int a[10];
.... 
int**a=&a;

Loulou24 :

Et puis un identifiant de tableau n'a pas d'adresse, puisque ce n'est qu'un identifiant. La seule chose qui soit stockée en mémoire ce sont les éléments du tableau.

La remarque de Loulou24 est exacte: Un identifiant de tableau n'a pas d'adresse : ce n'est qu'une valeur. Pourtant, il est possible de prendre l'adresse d'un identificateur de tableau et ceci est interprété par le compilateur de la façon suivante : &a est une valeur mais le type de cette valeur n'est pas int ** mais int (*)[] et cette valeur correspond à l'adresse du premier élément du tableau.

[Jean-Marc.Bourguet]

Je sens de la confusion.

Le nom d'un tableau ne designe pas un pointeur vers le premier element, il designe le tableau. Malheureusement, les tableaux "a la C" sont des types devaforises en C (et donc en C++) et donc les tableaux se comportent parfois de maniere etrange.

Pour commencer un tableau est dans un certain nombre de contexte converti implicitement en un pointeur vers le premier element. C'est pourquoi

Code :

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

1
2
int a[10];
int* p = a;

est possible et equivaut a

Code :

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

int* p = &a[0];

Il faut noter que ce n'est pas le cas de tous les contextes, le plus courant etant vraissemblablement

Code :

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

sizeof(a)

qui est loin d'etre la meme chose que

Code :

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

sizeof(&a[0])

Un autre contexte ou la conversion n'a pas lieu, c'est apres l'operateur &, donc

Code :

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

&a

a pour type

Code :

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

int (*)[10]

qui est un pointeur vers le tableau (et non vers le premier element du tableau, le type n'est pas le bon meme si l'adresse est la meme).

Une chose qui aide aussi a la confusion, c'est que

Code :

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

void f(int a[]);

equivaut a

Code :

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

void f(int* a);

[d-a-v-e]

c est sympa de nous eclaircir dans ce sujet mais je ne comprends pas quelquechose,
tu dis que dans

Code :

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

1
2
 
int a[10];

a pointe vers le tableau et non vers le premier element! ca veut dire quoi? un pointeur ne peux pas enregistrer deux adresse il est bien oblige de pointer vers le premier!
en plus, on voit que

Code :

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

1
2
3
4
 
cout<<a;
//et
cout<<&a[0];

affichent la meme adresse!
explique toi stp!

[JolyLoic]

a n'est pas un pointeur, et il n'a pas à pointer sur quoi que ce soit.

a est le nom d'une variable de type tableau, tout comme dans le code int b = 10, b est le nom d'une variable de type int, et non pas un pointeur.


Le point particulier est que l'expression 'a' est dans des contextes que Jean-Marc a explicités convertie en un pointeur sur le premier élément du tableau désigné par a.

[diogene]

Jean-Marc.Bourguet :

je sens de la confusion.

Je suis tout à fait d'accord avec tes explications. Mais "confusion...." Les tableaux sont complexes par principe en C alors que les pointeurs sont évidents. La complexité des tableaux vient de l'interprétation du compilateur : l'identificateur peut représenter deux choses différentes (ce n'est pas commode) :Il est résolu à la compilation (cas de sizeof(Tab) ou de &Tab) ou il est évalué cas de sizeof (Tab+...) , passage d'un identificateur de tableau en paramètre de fonction,... ou tout autre contexte , auquel cas l'identificateur (Tab) prend le type ( et la valeur correspondante) de "adresse du premier élément du tableau".
d-a-v-e :

en plus, on voit que

cout<<a;
//et
cout<<&a[0];affichent la meme adresse!

Pas surprenant :
a, &a[0], &a donneront la même valeur mais les types peuvent être différent
JolyLoic :

Le point particulier est que l'expression 'a' est dans des contextes que Jean-Marc a explicités convertie en un pointeur sur le premier élément du tableau désigné par a.

Pas d'accord. Ce n'est pas un pointeur mais simplement une valeur du type adresse de ..
Finalement, pour revenir sur le titre du sujet, l'identificateur d'un tableau n'est jamais un pointeur

[Jean-Marc.Bourguet]

tu dis que dans

Code :

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

1
2
 
int a[10];

a pointe vers le tableau

Non. J'ai ecrit que a est le nom du tableau et que son type est tableau de 10 entiers. De meme que dans

Code :

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

int b;

b est le nom d'un entier et que son type est entier.

en plus, on voit que

Code :

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

1
2
3
4
 
cout<<a;
//et
cout<<&a[0];

affichent la meme adresse! explique toi stp!

D'une part, il me semble avoir ecrit que dans pas mal de contextes, un tableau est converti implicitement en un pointeur vers le premier element. Nous sommes dans un tel contexte.

D'autre part, une adresse peut etre l'adresse de plusieurs objets. Un tableau et son premier element par exemple.

Il ne faut pas confondre adresse et pointeur. Un pointeur contient par essence une indication de type de l'objet pointe, une adresse est quelque chose de plus bas niveau et designe un emplacement memoire (la notion la plus proche en C++ d'une adresse est un void*).

[JolyLoic]

Le point particulier est que l'expression 'a' est dans des contextes que Jean-Marc a explicités convertie en un pointeur sur le premier élément du tableau désigné par a.

Pas d'accord. Ce n'est pas un pointeur mais simplement une valeur du type adresse de ..

Pas d'accord à 100%.

Quand on écrit a+1, a est converti, si c'était en adresse, a+1 pointerait un octet plus loin que le début du tableau nommé a. Or a+1 pointe sur le deuxième élément du tableau, donc on a gardé une information de type quand même, et donc a est converti en pointeur, et non en adresse.

[diogene]

JolyLoic :

Quand on écrit a+1, a est converti, si c'était en adresse, a+1 pointerait un octet plus loin que le début du tableau nommé a. Or a+1 pointe sur le deuxième élément du tableau, donc on a gardé une information de type quand même, et donc a est converti en pointeur, et non en adresse.

On est d'accord sur le principe, c'est une question de terminologie :
Je prend le mot adresse dans le sens de l'opérateur &. &x est pour moi une valeur : l'adresse de x (et n'est pas un pointeur au sens décrit plus bas). &x+1 ne repère pas (en général) l'octet "plus loin". Il existe une arithmétique propre aux valeurs de type adresse de qq chose.
Je prend le mot pointeur comme un objet (au sens large de variable, de lvalue, pas obligatoirement d'instance de classe) dont le type de la valeur est adresse de qq chose (au sens précédent).

[Jean-Marc.Bourguet]

Je prend le mot pointeur comme un objet (au sens large de variable, de lvalue, pas obligatoirement d'instance de classe) dont le type de la valeur est adresse de qq chose (au sens précédent).

Le probleme est que tu es le seul a utiliser pointeur dans ce sens. Le reste du monde utilise pointeur pour designer des types et les valeurs de ces types (exactement comme on utilise int, on dit par exemple que new retourne un pointeur ou bien on parle du pointeur nul).

[d-a-v-e]

je penses que de la meme maniere que un pointeur int pointe pas seulement vers une adresse (qui est l adresse du premier octet du int) mais aussi vers un int, c est a dire, il connait la grandeur de int ki est de 4 octets et c est pour quoi quand on incremente un pointeur int il gardera l adresse de 4 octets plus loin. alors aussi le nom d un tableau est un pointeur ki garde l adresse du premier octet du tableau mais il sait aussi que le tableau contient 10 variables et c est pour quoi quand j envoi le nom du tableau a sizeof() il me renvoi le nombre d octets du tableau entier et c est ce qu on appelle un (int * []).

[Laurent Gomila]

je penses que de la meme maniere que un pointeur int pointe pas seulement vers une adresse (qui est l adresse du premier octet du int) mais aussi vers un int, c est a dire, il connait la grandeur de int ki est de 4 octets et c est pour quoi quand on incremente un pointeur int il gardera l adresse de 4 octets plus loin. alors aussi le nom d un tableau est un pointeur ki garde l adresse du premier octet du tableau mais il sait aussi que le tableau contient 10 variables et c est pour quoi quand j envoi le nom du tableau a sizeof() il me renvoi le nombre d octets du tableau entier et c est ce qu on appelle un (int * []).

C'est vraiment pas pour faire mon rabat-joie, mais avec des phrases plus courtes, plus de ponctuation, des apostrophes et des majuscules en début de phrases, tes explications seraient tout de même beaucoup plus claires.

[Jean-Marc.Bourguet]

C'est vraiment pas pour faire mon rabat-joie, mais avec des phrases plus courtes, plus de ponctuation, des apostrophes et des majuscules en début de phrases, tes explications seraient tout de même beaucoup plus claires.

J'ajouterais quelques tentatives pour respecter l'orthographe et la syntaxe du francais et une once d'effort personnel (bien que cette derniere remarque concerne plus un autre thread que celui-ci). Le fait est que d-a-v-e ne donne pas envie de lui repondre.

[d-a-v-e]

Excusez moi!
Le probleme est que tout simplement je suis tout nouveau sur le forum!
J'espere que d'ici quelques jours mes messages seront plus clairs!

En attendant, je suis content de recevoir vos remarques!

merci!
d-a-v-e

[diogene]

Jean-Marc.Bourguet :

Le probleme est que tu es le seul a utiliser pointeur dans ce sens. Le reste du monde utilise pointeur pour designer des types et les valeurs de ces types

Je ne crois pas , tout le monde (mais je m'avance peut être) dit si j'écris int *a; que a est un pointeur. En tout état de cause, ça ne me gène pas de changer mon vocabulaire et je veux bien me ranger à l'avis du reste du monde. Ce qui me gène, c'est la confusion entre un objet (au sens large) et une valeur. Dire que &a est un pointeur et dire aussi que dans int *a; a est un pointeur me gène effectivement. Il faut choisir sa définition !
Alors dans int *a; a n'est pas un pointeur ? qu'en dit le reste du monde ?
ceci est une simplification de langage (que j'utilise aussi ) mais est une source de grosses confusions pour les débutants.
Illustration :
d-a-v-e :

je penses que de la meme maniere que un pointeur int pointe pas seulement vers une adresse (qui est l adresse du premier octet du int) mais aussi vers un int,

???? Voilà qu'un pointeur sur int pointe (mais pas seulement) vers une adresse! Non , un pointeur sur int est fait pour stocker l'adresse d'un int tout simplement

alors aussi le nom d un tableau est un pointeur

Je ne suis pas d'accord mais voir ci-dessus et les remarques de Jean-Marc.Bourguet

ki garde l adresse du premier octet du tableau

garde ? autrement dit, au nom du tableau est associée une variable (un pointeur ?) qui "stocke" l'adresse... Non , le nom du tableau est l'adresse (sauf pour sizeof et &)

mais il sait aussi que le tableau contient 10 variables et c est pour quoi quand j envoi le nom du tableau a sizeof() il me renvoi le nombre d octets du tableau entier et c est ce qu on appelle un (int * []).

???? sizeof ne renvoie jamais un (int * []).
Bon courage ensuite pour comprendre les tableaux en paramètres de fonction avec des idées aussi confuses!

Tu comprendras mes réticences à suivre sur cette voie le reste du monde

[Jean-Marc.Bourguet]

Jean-Marc.Bourguet :

Le probleme est que tu es le seul a utiliser pointeur dans ce sens. Le reste du monde utilise pointeur pour designer des types et les valeurs de ces types

Je ne crois pas, tout le monde (mais je m'avance peut être) dit si j'écris int *a; que a est un pointeur.

Pour moi pointeur est avant tout un type (une famille de type). On l'utilise aussi quasiment toujours à la place du plus formel valeur de type pointeur et, je l'admets sans peine, souvent à la place de variable de type pointeur. Ces utilisations de la métonymie sont courantes (on en trouve même dans la norme). Note qu'il se passe exactement la même chose pour les autres types. On va facilement dire que int b; déclare un entier b plutôt qu'une variable de type entier et que 5 est un entier plutôt qu'une valeur entière.

Ce que je conteste, c'est ta volonté de réserver pointeur aux variables.

En tout état de cause, ça ne me gène pas de changer mon vocabulaire et je veux bien me ranger à l'avis du reste du monde.

Si tu veux, je fais un relevé des utilisations de pointeurs dans la norme. Je te parie que je vais le trouver utilisé pincipalement pour désigner des types (après tout le style de la norme est très formel), ensuite des valeurs enfin des variables. J'ai pas d'autres références sous forme électronique pour faire une analyse.

Ce qui me gène, c'est la confusion entre un objet (au sens large) et une valeur.

Les confusions dans le langage courant entre contenant (l'objet) et contenu (la valeur) sont très courantes.

Dire que &a est un pointeur et dire aussi que dans int *a; a est un pointeur me gène effectivement. Il faut choisir sa définition !
Alors dans int *a; a n'est pas un pointeur ? qu'en dit le reste du monde ?

Si je veux parler formellement, je dirais que &a est une expression de type pointeur vers int et a une variable de type pointeur vers int.

[Jean-Marc.Bourguet]

J'avais pas vu ceci:

Non , le nom du tableau est l'adresse (sauf pour sizeof et &)

NON

Les tableaux sont des types de seconde zone en C et en C++, ils ont des limitations difficilement explicable sans considerer l'evolution des langages, il y a un certain nombre de choses qui entrainent une confusion avec les pointeurs, mais ce sont quand meme des types differents des pointeurs et un identificateur de tableau se comporte differemment que ne se comporterait un pointeur constant vers son premier element. Voir ces differences comme des exceptions a une regle est problematique (tu as oublie dans tes "exceptions" typeid, la resolution de surcharge, les references, les templates, et je dois en oublier aussi) et expliquer tout va devenir rapidement tres complexe (considere le cas de tableaux de tableaux). Considerer qu'il y a une conversion implicite des tableaux en pointeurs explique bien tout (c'est d'ailleurs comme ca que la norme est redigee, je m'engage a peu de chose en affirmant qu'il va etre difficile de prouver qu'une autre approche est equivalente).

[diogene]

Nos points de vue ont été clairement exprimés. Laissons à d'autres le soin de donner leur avis sur le sujet s'ils le souhaitent

[d-a-v-e]

qulequn peut m expliquer comment faire pour citer dans mon message des paroles d un autre message?