rappel sur sizeof() - Page 1

si je me souviens bien ca donne la taille en byte d'un bloc de donnees, tableau, structure, union y compris.
Avec le tableau de structure ci-dessous :

struct {
 char *str;
 char *strbuf;
 short len;
} strdata[5];

Est que sizeof(strdata) me ramene la taille du tableau de structure.
Si cela ne fonctionne pas comme cela , je serai oblige de definir une structure 'data' avant de declarer mon tableau 'strdata'.

Parceque ce que je veux c'est initialiser mon tableau de structure avec l'instruction suivante :
memset( strdata, 0, sizeof(strdata));

c'est plus court que la solution :

typedef data struct {
 char *str;
 char *strbuf;
 short len;
};
data strdata[5];
memset( strdata, 0, 5*sizeof(data) )

tu sais que tu peux tester tout ça avec des printf, et que ça irait bien plus vite que poser la question ici ?

Je ne sais pas si la 1ère méthode mais on s'en fou parceque "5*sizeof(data)" est connu lors de la compilation, donc la 2e méthode prends autant de place que la 1ère, si ce n'est moins.
Il faut mieux utiliser la 2e méthode (qui est accésoirement plus claire/simple).

#define DATA_COUNT 5

typedef data struct {
 char *str;
 char *strbuf;
 short len;
};

data strdata[ DATA_COUNT ];
memset( strdata, 0, DATA_COUNT*sizeof(data) )

et?

C'est mieux

pendant que on y est, on a qu'a faire:

#define DATA_COUNT 5
#define DATA_INIT_VALUE 0
typedef data struct {
 char *str;
 char *strbuf;
 short len;
};

data strdata[ DATA_COUNT ];
memset( strdata, DATA_INIT_VALUE, DATA_COUNT*sizeof(data) )

non?

Nan, le "0" étant moins critique que le nombre d'éléments dans le tableau pour la maintenabilité du code, pour autant qu'il me soit permis de juger sur ce bout de code. Mais javoue, c'est du chipotage

Si vous voulez chipoter, y'a bien d'autres choses à dire
(à commencer par la syntaxe du typedef qui est mauvaise, sans compter le fait que typedef struct c'est mal ^^)

Les deux solutions marchent, mais effectivement comme le dit Ximoon tu seras tôt ou tard obligé de recopier le nb d'éléments du tableau ailleurs, et donc il vaudra mieux faire un #define... (mais tu peux parfaitement utiliser la première solution tout en prenant un #define)

Sauf si tu préfères passer par sizeof(strdata)/sizeof(*strdata) pour connaître le nb d'éléments du tableau, ça marche aussi ^^ (mais c un peu lourd si tu t'en sers souvent)

Jyaif :
pendant que on y est, on a qu'a faire:

#define DATA_COUNT 5
#define DATA_INIT_VALUE 0
typedef data struct {
 char *str;
 char *strbuf;
 short len;
};

data strdata[ DATA_COUNT ];
memset( strdata, DATA_INIT_VALUE, DATA_COUNT*sizeof(data) )

non?

euh, ça n'aurait aucun sens de prendre une DATA_INIT_VALUE non nulle, un pointeur qui vaut 0x12121212 ne risque pas d'être très utile (enfin, sauf si le but c'est justement que le pointeur n'ait aucun sens, pour débugger plus facilement des initialisations manquantes)

Arreter de chipoter:
Dans mon projet y a Header specialement dedie au MACRO.
c'etait pour faire vite que j'ai ecrit 5.

Jyaif :
Je ne sais pas si la 1ère méthode mais on s'en fou parceque "5*sizeof(data)" est connu lors de la compilation, donc la 2e méthode prends autant de place que la 1ère, si ce n'est moins.
Il faut mieux utiliser la 2e méthode (qui est accésoirement plus claire/simple).

Oui mais cette structure ne me sert a rien d'autre apres.

---

Et pour repondre a Zephir, j'ai poster juste avant d'aller au cours en esperant obtenir une reponse une fois les cours fini.

Zephyr :
Si vous voulez chipoter, y'a bien d'autres choses à dire
(à commencer par la syntaxe du typedef qui est mauvaise, sans compter le fait que typedef struct c'est mal ^^)

je savais pas qu'on n'avais le droit de faire ca sur des structures !

Zephyr :
(à commencer par la syntaxe du typedef qui est mauvaise, sans compter le fait que typedef struct c'est mal ^^)

Pourquoi ?
a structure }; typedef struct t_type Type;

J'avoue avoir souvent vu des styles du genre :struct t_type
{
  // ... Le contenu de l

: typedef struct { // ... Le contenu de la structure }Type;Mais personnellement je trouve que c'est plus rapide d'écrire

Quel est le pb ?

le problème c'est qu'il a écrit :

typedef data struct { 
 char *str; 
 char *strbuf; 
 short len; 
};

au lieu de :

typedef struct { 
 char *str; 
 char *strbuf; 
 short len; 
} data;

(cf post #6 ^^)
(btw dans ton exemple ça serait plutot t_type à la place de Type et s_type à la place de t_type je pense)

Sauf si tu préfères passer par sizeof(strdata)/sizeof(*strdata) pour connaître le nb d'éléments du tableau, ça marche aussi ^^ (mais c un peu lourd si tu t'en sers souvent)

#ifndef numberof
# define numberof(x) (sizeof (x)/sizeof(*(x)))
#endif

A manger dans toutes les chaumieres.

Moui enfin comme le comportement de sizeof est particulier dans ce cas-là, en faire une macro c'est un coup à oublier qu'elle ne fonctionne qu'avec un type bien particulier de paramètre, coté lisiblité de la source finalement ça n'aide pas bcp :/

#ifndef numberof
# define numberof(x) ((sizeof(x)==sizeof(&*(x)) ? (assert(!"unsafe numberof() call, make sure you are actually applying it to an array and not a pointer"),0) : 0), sizeof (x)/sizeof(*(x))))
#endif

?

(ça fera des faux positifs pour char[4], short[2], et long[1], mais je crois pas qu'on puisse faire autrement...)

pas con comme méthode mais bon rien qu'en regardant la ligne tu vois qu'il y a un problème, j'irai pas mettre ça ds une source perso

sizeof(&*(x)), ou sizeof(*&(x)) ?

C'est bien sizeof(&*(x)) : si x est un tableau (par exemple int[42]), *x sera un int, et &*x sera un int*. Donc sizeof(&*x)=4 sera différent de sizeof(x)=42*2, donc on est sûr que x n'est pas un simple pointeur et que sizeof(x) est bien le nombre d'éléments du tableau.

sizeof(*&x), lui, est tjs égal à sizeof(x) que x soit un tableau ou non, et en plus n'est pas toujours défini (enfin pour un tableau, il devrait tjs l'être, remarque...)



Zephyr>
vi c ultra-crade, mais bon t'es pas censé la voir la ligne en question, et puis tu es qd même *certain* de ne pas te planter, ça pourrait être utile (enfin, perso j'utiliserais pas ça pour un programme portable, au cas où sur une plateforme exotique on tomberait sur un tableau qui fait exactement la taille d'un pointeur : en revanche rien ne t'empêche d'utiliser cette définition quand toi tu compiles, pour t'assurer que les numberof() sont bien ok, et d'utiliser la définition de PpHd pour les versions publiques...)

Et puis il y a un autre pb, c'est que les assert() sont dynamiques et pas statiques : tu peux t'en sortir en appelant une fonction définie nulle part à la place de assert() (en priant pour que le compilo supprime l'appel de fonction s'il ne peut pas être atteint, sinon la compilation échouerait => pas complètement portable, mais bon si c juste pour toi c pas un pb), ou en greppant la chaîne en question dans l'exécutable (mais bon, ça c encore moins portable), mais t'as raison, c bien dégueulasse et ça apporte pas gd chose par rapport à #define ARRAY_SIZE Enfin ça aurait été sympa si le C avait prévu un numberof() ou au moins un truc qui balance une erreur si l'argument n'est pas un tableau, parce que sizeof() est très casse-gueule de ce point de vue-là...

1. Je trouve numberof tres lisible.
2. Faut juste savoir que ca ne s'utilise pas sur un pointeur.
3. Dans le pire des cas ou tu te plantes, ta suite de tests le detectera tout de suite (ou alors elle est minable).
4. Utiliser #define ARRAY_SIZE signifie donc que c'est constant, donc que tu utilises une section data / bss / stack, donc que tu peux ecrire de telle facon que ton numberof marche.
5. Perso je m'en sers surtout pour

const struct toto tab[] = {
 {}, {}, {}, ... {}
};

6. Si c'est un pointeur, le C n'a aucun moyen de connaitre sa taille.

2. On est d'accord, mais ce n'est pas clair pour qqun d'extérieur au code : qqun qui veut changer un tableau statique en un truc alloué dynamique pensera à faire attention à sizeof(), mais ne pensera pas forcément à numberof()...

4. Oui, mais la nuance importante c'est que la déclaration du tableau n'est pas au même endroit que son utilisation : tu ne sais pas forcément qu'il faut réécrire le numberof(), justement (même si c'est possible de le réécrire), d'où l'intérêt de mettre une erreur plutôt que d'échouer silencieusement...

5. Vi moi aussi je m'en sers, mais ça reste "mal" pour autre chose qu'une utilisation strictement locale

6. Ben oui, il faudra modifier l'appel à numberof(), d'où l'intérêt de ne pas échouer silencieusement...

5. utiliser des tableaux pour autre chose que des trucs locaux, c'est mal.

ah ben c'est nouveau ça... on utilise quoi alors, sinon ? (enfin surtout "pourquoi")

pointeurs + allocations ?

Zephyr :
(enfin surtout "pourquoi")

Pour éviter les failles à buffer overflow partout

[edit] mmm, en réfléchissant, que ce soit global ou local ca change pas grand chose. Parce que ça consomme pendant toute l'exécution ?

heu faut le vouloir quand même, tu peux très bien avoir besoin d'un gros tableau de structures en global, static const par exemple, c'est difficilement remplaçable par autre chose (enfin ... efficacement, je veux dire, sinon c'est sûr qu'on peut faire des trucs aussi jolis que ce qu'a proposé Jyaif )

"static"
^^ J'appelle ca du local, mais bon.

Oh tu peux appeler ça comme tu veux en effet, je commence à mieux comprendre pourquoi on est pas d'accord

donc en gros,

static const char blabla[12];
void function1(void)
{ ... }
void function2(void)
{ ... }

là c'est "local" je suppose, et

void function1(void)
{ static const char blabla[12]; ... }
void function2(void)
{ ... }

là c'est ... ? encore + local ? ou bien un autre mot que j'ignore peut-être ^^
enfin bon le 1er cas chez moi ça s'appelle une variable globale, exportée ou non :/

Je pense que PpHd parlait de l'utilisation du qualifieur static à l'intérieur d'une fonction (donc ton deuxième cas).

Mais quelle est la différence entre une variable static ou non, lorsque celle-ci est déclarée en-dehors de toute fonction ?

Sasume :
Mais quelle est la différence entre une variable static ou non, lorsque celle-ci est déclarée en-dehors de toute fonction ?

pour les variables globales, static fait que leur portée est limitée au fichier où elles sont déclarées (en somme, ça en fait des variables globales locales à un fichier ^^ )