Lire un tableau avec fread : besoin de "&" ?

Bonjour,
Depuis toujours, pour lire un tableau en binaire dans un fichier, j'utilise fread de cette manière :

Code:

---

1 2 3

char tableau[25]; FILE *fichier = fopen("save", "rb"); fread(&tableau, sizeof(tableau), 1, fichier);

---

Or, je viens de pércuter que, un tableau étant déjà une sorte de pointeur, pour désigner leur adresse il ne faut pas mettre de "&".

Il faudrait donc faire :

Code:

---

fread(tableau, sizeof(tableau), 1, fichier);

---

Mais je n'ai jamais eu de problème, et j'ai essayé les 2, je n'ai pas vu de différence. Comment est-ce possible ? Cela ne devrait pas être une erreur abominable ? Est-ce le compilateur (j'utilise codeblock) qui corrige tout seul la faute ? Et surtout est ce que je peux continuer à écrire "&tableau" sans risque ?

Merci d'avance! :)

C'est parce que les 2 expressions ont la même valeur que cela fonctionne ;)

https://gradot.wordpress.com/2012/08...ointeurs-en-c/

Ahh d'accord, merci! Super l'article pour comprendre la différence entre tableau et pointeur! :D

Je pense qu'il y a déjà un problème de compréhension avec les pointeurs avant même de pouvoir comparer tableau et pointeur...

Qu'est-ce pour toi la variable tableau seul, sans autres opérateurs autour ?

Pour l'instant je dirais que c'est un pointeur sur la première case du tableau, mais je n'ai pas encore lu l'article et je m'attend à ce que ce soit un peu plus complexe que ça.

Citation:

---

Pour l'instant je dirais que c'est un pointeur sur la première case du tableau, mais je n'ai pas encore lu l'article et je m'attend à ce que ce soit un peu plus complexe que ça.

---

Alors peut-être que c'est le terme pointeur qui n'est pas clair, en ce qui me concerne je préfère dire que tableau est l'adresse du 1^er élément du tableau. Ce qui est équivalent à exactement ce terme si on traduit

Code:

---

char *p = &(tableau[0]);

---

Je préfère cette dernière que je trouve plus explicite quand on a pas une bonne maîtrise des pointeurs... une fois cette maîtrise, tu pourras utiliser tableau sans doute possible.

Autre solution possible

Code:

---

char *p = &(*tableau);

---

Au choix l'une des deux expriment clairement ce que tu veux, c'est à dire une adresse, car l'esperluette est l'opérateur renvoyant l'adresse de l'objet.

Petit point de vocabulaire: un pointeur est une variable contenant une adresse.

Ainsi, &(tableau[0]) est une expression dont la valeur est l'adresse du premier élément de tableau. Cette valeur est assignable à un pointeur de type compatible.

Citation:

---

en ce qui me concerne je préfère dire que tableau est l'adresse du 1er élément du tableau

---

Sauf que c'est faux : un tableau n'est ni un pointeur vers ni l'adresse de son premier élément. Ce qui est vrai, c'est que le tableau est généralement converti en ceci.

Je me permets de compléter la correction au combien importante de Bktero.

l'une des grandes différences, c'est le résultat de sizeof.

Code:

---

1 2 3 4 5 6 7 8 9 10 11

#include <stdio.h> int main() { int tableau [] = {1,2,3,4,5,6,7,8}; int *copie = tableau;   printf("taille du tableau = %d, taille du pointeur = %d, taille de l'adresse du premier élément", sizeof(tableau), sizeof(copie), sizeof(&(tableau[0])));   printf("nombre d'éléments du tableau = %d", sizeof(tableau)/ sizeof(tableau[0]));   return 0; }

---

Citation:

---

Sauf que c'est faux : un tableau n'est ni un pointeur vers ni l'adresse de son premier élément. Ce qui est vrai, c'est que le tableau est généralement converti en ceci.

---

Sauf que je ne parle pas d'un tableau, mais bien de la variable tableau du PO...

variable qui est bien un tableau (char tableau[25];)

Humm, du coup je ne sais plus comment l'exprimer, je vais simplement le sortir en code

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12

int main(void){   char tableau[4] = {'a', 'b', 'c', '\0'};     printf("%p\n", (void *)tableau); printf("%p\n", (void *)&(tableau[0])); printf("%p\n", (void *)&(*tableau));     return 0; }

---

Qui sortent la même adresse... sinon après je sais plus comment dire mieux.

Oui, c'est bien convertible.
Un tableau est toujours convertible en pointeur vers l'adresse de son premier élément (c'est comme ca qu'on peut passer un "tableau" en paramètre d'une fonction)
Mais il n'est pas un pointeur.

Bonjour

Citation:

---

Envoyé par Bktero

Sauf que c'est faux : un tableau n'est ni un pointeur vers ni l'adresse de son premier élément. Ce qui est vrai, c'est que le tableau est généralement converti en ceci.

---

Juste pour apporter quelque précision en plus de ce que Bktero a dit. Un tableau n'est pas un pointeur, je dirais plus précisément qu'un tableau est un espace mémoire défini en fonction du nombre d'éléments et du type de ces éléments et ne peux être redimensionné. Pour le redimensionnement d'un tableau en utilisera des tableaux dite dynamiques.
Un pointeur quant à elle (variable pointeur) est une variable comme sont l'indique, qui pointe strictement sur un espace mémoire et ne manipule que des adresses .L'accès aux données que pointe les pointeurs s'effectue par une étoile ou avec des crochets comme s'il s'agissait d'un tableau mais en réalité, il existe bien une différence entre pointeurs et tableaux qui réside uniquement (combien même que "tableaux et pointeur" s'utilisent de la même façon pour accéder à leur donnée mais) sur le fait qu'une variable pointeur peut pointer sur une autre zone mémoire que celle qu'elle a pointé précédemment et le tableau ne peut faire cela.

Citation:

---

Envoyé par Bktero

Ce qui est vrai, c'est que le tableau est généralement converti en ceci.

---

Il est vrai qu'une expression tableaux ( tab[i] ) est remplacée par celle -ci ( *(ptr+i) ) lors de la compilation (je ne suis pas expert) mais pensez-vous (@Bktero) que le compilateur transforme le code ou il applique juste une arithmétique de pointeur ?. En clair manipule t'il juste l'adresse du tableau pour accéder aux éléments de celui-ci (en ajoutant la taille en octet du type de l'élément du tableau ou pointe sur le tableau afin de la manipuler voire autre ).Vos réponses m'éclairement surement
à bientôt

Citation:

---

Il est vrai qu'une expression tableaux ( tab[i] ) est remplacée par celle -ci ( *(ptr+i) ) lors de la compilation (je ne suis pas expert) mais pensez-vous (@Bktero) que le compilateur transforme le code ou il applique juste une arithmétique de pointeur ?. En clair manipule t'il juste l'adresse du tableau pour accéder aux éléments de celui-ci (en ajoutant la taille en octet du type de l'élément du tableau ou pointe sur le tableau afin de la manipuler voire autre ).Vos réponses m'éclairement surement

---

Je ne sais pas trop quoi te répondre...

Je sais pas si on peut dire qu'une expression est "remplacée" par une autre. Elles sont simplement la même signification, la même valeur. Qu'est ce que cela veut dire "le compilateur transforme le code" ? Qu'il remplace un morceau de code source par un autre avant de compiler ? Il n'a pas besoin de faire ça, il compile ligne par ligne sans remplacer quoi que ce soit : ce n'est de toute façon pas nécessaire de remplacer puisqu'il est en train de l'interpréter et s'il sait ce que ça veut dire, pourquoi remplacer par autre chose pour interpréter ensuite cette autre chose ?

En gros, tab[i] est équivalent à *(tab + i) (ton code peut écrire soit l'un soit l'autre) et le compilateur remplace tab l'adresse de l'objet en mémoire. Si au lieu de tab, tu avais ptr (un pointeur) alors le compilateur le remplacerait par la valeur de la variable.

J'ai essayé de regarder un peu d'assembleur pour comprendre. Voici le code source :

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13

#include <stdlib.h>   int f(void) { int array[10]; return array[5]; }   int g(void) { int *pointer = malloc(10); return pointer[5]; }

---

Je compile et je dump l'assembleur (ARM) :

$ arm-none-eabi-gcc -O1 main.c -c && arm-none-eabi-objdump -d -l main.o

main.o:     file format elf32-littlearm


Disassembly of section .text:

00000000 <f>:
f():
   0:	e24dd028 	sub	sp, sp, #40	; 0x28
   4:	e59d0014 	ldr	r0, [sp, #20]
   8:	e28dd028 	add	sp, sp, #40	; 0x28
   c:	e12fff1e 	bx	lr

00000010 <g>:
g():
  10:	e92d4008 	push	{r3, lr}
  14:	e3a0000a 	mov	r0, #10
  18:	ebfffffe 	bl	0 <malloc>
  1c:	e5900014 	ldr	r0, [r0, #20]
  20:	e8bd4008 	pop	{r3, lr}
  24:	e12fff1e 	bx	lr

Ce sont les lignes 4 et 1c qui sont intéressantes pour comparer pointeurs et tableaux. Notez que r0 est le registre dédié pour les valeurs de retour ainsi qu'au premier paramètre de fonctions.
- Pour f() (ligne 4), on met dans r0 la valeur trouvée à sp + 20 (sp = stack pointer). Le tableau est bien déclaré sur la pile (ligne 0) et le 5e élément est 20 octets (5 * sizeof int = 5 * 4 = 20). On décrémente ensuite sp pour détruire le tableau crée sur la pile.
- Pour g(), malloc() met l'adresse de la zone allouée dans r0 (ligne 18). Le retour de g() est donc la valeur trouvée à l'adresse contenu dans r0 augmentée de 20 octets.
Pour les 2 fonctions, l'appelant trouvera la valeur voulue dans r0 une fois f() et g() terminée.

Bonjour
merci pour la réponse et l'exemple ;)
à bientôt

Bonjour

Citation:

---

Envoyé par leternel

Un tableau est toujours convertible en pointeur vers l'adresse de son premier élément (c'est comme ca qu'on peut passer un "tableau" en paramètre d'une fonction)
Mais il n'est pas un pointeur.

---

Effectivement un tableau n'est pas un pointeur. Un tableau est un tableau, et un pointeur est un pointeur.
Mais c'est quoi un pointeur précisément ? C'est tout simplement une variable dédiée au stockage d'une adresse. Rien de plus, rien de moins (et rien d'autre). Et c'est là que le mécanisme habituellement associé aux tableaux entre en jeu. En effet, étant donné que chaque élément du tableau possède une adresse, alors en écrivant char *pt=&tableau[0] on ne fait que recopier l'adresse du premier élément dans un pointeur apte à la recevoir. Et étant donné que les éléments se suivent tous, alors en incrémentant le pointeur on lui fait alors générer l'adresse de l'élément suivant ce qui permet ainsi de traiter ledit élément. Et ainsi de suite pour tous les autres (et au delà si on a envie d'essayer...)

Le reste n'est que raccourci (tableau équivalent à &tableau[0]) probablement traduit par le compilo...

Citation:

---

Envoyé par sambia39

Pour le redimensionnement d'un tableau en utilisera des tableaux dits dynamiques.

---

Dans ce cas là, ce ne sont plus des tableaux. On alloue X cases mémoires dont on récupère l'adresse de la première (et comme elles se suivent on aura alors toutes les autres par simple calcul). Et le raccourci d'écriture permet d'utiliser cette zone comme si c'était un tableau. Mais là non plus ce n'en est pas un.
D'ailleurs, petit danger, l'OS peut très bien déplacer la zone allouée lors d'un redimensionnement éventuel. Dans ce cas, celui qui (par besoin perso) aurait gardé l'adresse initiale dans un second pointeur, se retrouve alors avec une adresse qui ne correspond à plus rien de concret (et ça, ça ne peut pas arriver avec un tableau)...

Mais toutefois tout ceci n'était que du pinaillage de détail. Une fois qu'on a bien compris, on peut alors (dans un souci de simplification du langage), amalgamer tableaux et pointeurs et les considérer comme étant sensiblement équivalents...

Citation:

---

Effectivement un tableau n'est pas un pointeur. Un tableau est un tableau, et un pointeur est un pointeur.
Mais c'est quoi un pointeur précisément ? C'est tout simplement une variable dédiée au stockage d'une adresse. Rien de plus, rien de moins (et rien d'autre). Et c'est là que le mécanisme habituellement associé aux tableaux entre en jeu. En effet, étant donné que chaque élément du tableau possède une adresse, alors en écrivant char *pt=&tableau[0] on ne fait que recopier l'adresse du premier élément dans un pointeur apte à la recevoir. Et étant donné que les éléments se suivent tous, alors en incrémentant le pointeur on lui fait alors générer l'adresse de l'élément suivant ce qui permet ainsi de traiter ledit élément. Et ainsi de suite pour tous les autres (et au delà si on a envie d'essayer...)

Le reste n'est que raccourci (tableau équivalent à &tableau[0]) probablement traduit par le compilo...

---

Merci, c'est exactement à cela que je pensais avec de grosses difficultés à l'exprimer...