salut,
 
désolé de poser autant de questions sur les pointeurs ....
 
J'ai lu que  

 
est différent de  

 
mais je ne comprend pas ce qu'on peut faire de l'instruction 1, une fois qu'on la déclarée. Ca sert int (*i)[5]; ??? Si oui comment fait on pour acceder aux élements du tableau ?
 
merci par avance    

Avec int (*i)[5], i+1 pointe 5*sizeof(int) octets après i
Avec int *i[5], i+1 pointe sizeof(int *) octets après i
Avec int i[5], i+1 pointe sizeof(int) octets après i

 
merci pour ta réponse
 
ah oui ??? je ne comprend pas alors, car je me représentait le int (*i)[5] comme ca :
 
adresse de i  pointe vers ...       un tableau de 5  
|i |-------------------------------> | | | | | |  
 
 
ce n'est pas ca ??

Oui, et i+5 c'est le début du tableau de 5 suivant, qui est donc 5*sizeof(int) octets plus loin.

 
d'accord, mais "i+1 pointe 5*sizeof(int) octets après i" je comprend pas, ce serai pas plutot i+5 ?

Quand tu as un pointeur p de type T, p+1 vaut p plus sizeof(*p). Arithmétique des pointeurs, tout ça.

en gros, ton compilo n'est pas bete. Il sait de combien d'octet avancé pour aller au 'int suivant'. Car il sait que un int c'est 4 octets (selon les architectures, mais la n'est pas la question)
donc, quand tu fais i+1 il sait qu'il part de l'adresse de i puis il avance de 4 octets et te renvois cette adresse.
 
Ca t'arrive jamais de travailler sur des char * et d'incrementé de 1 pour parcourir une chaine ? Ton commpile avance de 1 octet à chaque incrémentation car il sait que un char tient sur 1 octet.
 
 
(Si avec toutes nos explications tu comprends toujours pas )

http://fr.lang.free.fr/cours/Langa [...] e_v2.0.pdf
Chapitre X: Les pointeurs

ok je crois que je comprend Mais est-il possible d'initialiser, par exemple remplir les cases du tableau :

on peut rien en faire de ce truc ...??? ET si par exemple ou veut acceder a la case deux du tableau ???

merci pour la ref, à la page 164, je lis (en retrranscrit) :

donc, et c'est ce que je pensais aussi, tab est la meme chose que &tab[0]. Or, si je fais :

j'ai des résultats différents pour sizeor(t)   :

alors  que

Tu accèdes à ton 2ème élément comme ça :

Attention quand même, j'ai l'impression qu'un truc t'échappes : quand tu définis t avec ta ligne "int (*t)[5];", seul le pointeur t est défini. Le tableau de 5 éléments, lui n'est pas défini. Il faut que tu le créé avec malloc ou autre chose, puis que tu mette son adresse dans t.
 
Ensuite oui, un tableau c'est l'adresse de son premier élément. Ca ne veut pas dire que c'est la même chose qu'un pointeur vers son premier élément. Ca reste un tableau, et un tableau c'est pas la même chose qu'un pointeur. En gros, si tu veux, un tableau c'est l'adresse de son premier élément, plus le fait que le compilo sait des choses en plus à son sujet (en particulier son nombre d'élément s'il a été défini lors de sa déclaration).

 
ahhh ...oui un truc m'échappe effectivement ! alors je ne comprend pas pourquoi seul le pointeur est défini. En fait je pensais que  

 
c'était quelque chose dans le genre de  

enfin dans l'idée, sans prendre en compte les types : un pointeur vers un tableau constant de 5 éléments.  
 
Si je comprend bien pour la question deux, on devrait bien avoir la même chose avec un malloc alors ? cad pour
 

 
on a :
 

 
c'est ça ?  

Il faut te poser la question à chaque fois de quel type est ta déclaration.
int t[] = {1,2,3}
t est une zone mémoire qui contient 3 int.
Donc, la 't' occupe la taille de 3 int, soit 12 octets.
&t[2] -> Tu demandes l'adresse (& ) de la zone mémoire qui est a t + 2. Comme cette 'chose' te renvois une adresse, ca te renvois la taille d'une adresse. La hasard fait bien les choses, une adresse tient sur 4 octets, comme les int. Fait attention.
 
Retranscrit dans une phrase ce que tu écris pour mieux comprendre tes déclarations
Quand tu mets un &, ca renvoi toujours une adresse donc 4 octets
 
En francais tu peux par exemple dire
& -> l'adresse de ...
* -> la ou pointe ...

oui mais justement, je croyais que t était une adresse, non ??? Puisque t est la même chose que &t[0] et t + 0

Oui c'est vrai. Et alors ???

 
alors si c'est la même chose pourquoi ca ne renvoi pas la meme taille ?  

Parce que c'est pas la même chose Un tableau c'est pas un pointeur, un pointeur c'est pas un tableau. Même si les deux notions sont étroitement liées, et que l'un peut souvent être assimilé à l'autre.
 
Edit : tiens je viens de trouver l'image qui tue (peut-être). Les pointeurs et les tableaux, c'est un peut comme les pointeurs et les adresses. Un pointeur c'est un peu une adresse, mais ça ne se résume pas à un adresse. Le compilo sait des trucs en plus sur un pointeur, en particulier le type pointé. Et bien un tableau c'est un peu pareil. C'est un peu comme un pointeur, mais pour le compilo c'est pas la même chose. En particulier le compilo sait combien un tableau a d'éléments.

Comme le dit Matafan, ce n'est pas la même chose    
En fait, elem[x] va te donner le contenu de la "xième" case d'un tableau, et "*(elem + x) va aller à l'adresse "elem + x" pour te donner le contenu qu'il y a à cette adresse.
 
Les deux contenus sont la même chose mais les outils utilisés pour les récupérer ne sont pas les mêmes...

 
oiu je suis d'accrod avec vous, un tableau c'est différent d'un pointeur. Mais une adresse c'est une adresse, non ?  
 
   

Oui, mais quand tu demandes "sizeof(t)", le compilo sachant que "t" est défini comme tableau va aller plus loin que le bout de son nez et regardera ce qu'il connait du tableau. Et il te renverra la taille du tableau alors que, dans l'absolu, la case dénommée "t" ne contient effectivement qu'une adresse...

 
     
 
il est fort ce compilo