Version imprimable
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?
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.
d-a-v-e :
Loulou24 :Citation:
mais pkoi je ne peu pas ecrire
Code:
2
3
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.Citation:
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.
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 pourquoiest possible et equivaut aCode:
2
Il faut noter que ce n'est pas le cas de tous les contextes, le plus courant etant vraissemblablementCode:int* p = &a[0];
qui est loin d'etre la meme chose queCode:sizeof(a)
Un autre contexte ou la conversion n'a pas lieu, c'est apres l'operateur &, doncCode:sizeof(&a[0])
a pour typeCode:&a
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).Code:int (*)[10]
Une chose qui aide aussi a la confusion, c'est queequivaut aCode:void f(int a[]);
Code:void f(int* a);
c est sympa de nous eclaircir dans ce sujet mais je ne comprends pas quelquechose,
tu dis que dans
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!Code:
2
en plus, on voit que
affichent la meme adresse!Code:
2
3
4
explique toi stp!
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.
Jean-Marc.Bourguet :
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".Citation:
je sens de la confusion.
d-a-v-e :Pas surprenant :Citation:
en plus, on voit que
cout<<a;
//et
cout<<&a[0];affichent la meme adresse!
a, &a[0], &a donneront la même valeur mais les types peuvent être différent
JolyLoic :
Pas d'accord. Ce n'est pas un pointeur mais simplement une valeur du type adresse de ..Citation:
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.
Finalement, pour revenir sur le titre du sujet, l'identificateur d'un tableau n'est jamais un pointeur
Non. J'ai ecrit que a est le nom du tableau et que son type est tableau de 10 entiers. De meme que dansCitation:
Envoyé par d-a-v-e
b est le nom d'un entier et que son type est entier.Code:int b;
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.Citation:
en plus, on voit queaffichent la meme adresse! explique toi stp!Code:
2
3
4
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*).
Pas d'accord à 100%.Citation:
Envoyé par diogene
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.
JolyLoic :
On est d'accord sur le principe, c'est une question de terminologie :Citation:
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.
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).
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).Citation:
Envoyé par diogene
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.Citation:
Envoyé par d-a-v-e
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.Citation:
Envoyé par Loulou24
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
Jean-Marc.Bourguet :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 !Citation:
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
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 :
???? 8O 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 simplementCitation:
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,
Je ne suis pas d'accord mais voir ci-dessus et les remarques de Jean-Marc.BourguetCitation:
alors aussi le nom d un tableau est un pointeur
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 &)Citation:
ki garde l adresse du premier octet du tableau
???? 8O sizeof ne renvoie jamais un (int * []).Citation:
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 * []).
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
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.Citation:
Envoyé par diogene
Ce que je conteste, c'est ta volonté de réserver pointeur aux variables.
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.Citation:
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.
Les confusions dans le langage courant entre contenant (l'objet) et contenu (la valeur) sont très courantes.Citation:
Ce qui me gène, c'est la confusion entre un objet (au sens large) et une valeur.
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.Citation:
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 ?
J'avais pas vu ceci:
NONCitation:
Envoyé par diogene
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).
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
qulequn peut m expliquer comment faire pour citer dans mon message des paroles d un autre message?
Petit bouton en haut en droite du message que tu veux citer --> "citer"...
Il y a une FAQ pour le BBcode.
http://www.developpez.net/forums/faq.php?mode=bbcode#4
une adresse est toujours l adresse d un octet dans la memoire!Citation:
Envoyé par diogene
puisque un int en a 4 il ne peux pas stocker 4 adresses, le pointeur garde seulement l adresse du premier octet, et le type de la variable qui est int, pour savoir que la variable se termine 4 octet apres l adresse stocker!
si j affiche la valeur du pointeur, il me sort seulement lune adresse!!
c est la meme chose pour un pointeur vers un (int [10]) il retirnt l adresse du premier octet et il reserve jusqua 10 * int (4 octets).
quand j envoi le tableau dans sizeof , il reconnait jusqua ou la place est reserve et m affiche le nombre d octets!!
Bonjour à tous,
Je vais essayer de vous dire comment je vois cela avec mes mots.
Une variable fait toujours référence à une adresse mémoire,
que ce soit une variable simple comme un int, un tableau, un pointeur
ou une structure. C'est le contenu de la mémoire à cette adresse qui
donne la valeur de la variable.
Si c'est un int la mémoire référencée par cette variable devrait contenir
la valeur de l'entier codé sur un certain nombre d'octet.
Si c'est un pointeur la mémoire référencée par cette variable
devrait contenir une adresse mémoire.
Si c'est un tableau la mémoire référencée par cette variable
devrait contenir éffectivement les données du tableau.
(devrait contenir car elles doivent être initialisé bien sûr).
Le tableau n'est donc pas vraiment un pointeur puisqu'il ne référence
pas une zone mémoire déstiné à contenir une adresse mémoire.
Mais il peut s'utiliser comme un pointeur constant, comme un pointeur
peut d'ailleurs s'utiliser avec la syntaxe d'un tableau (opérateur crochet).