Existe-t'il un type tenant sur 2 octets ?

Dans l'aide de C++ Builder, j'ai trouvé concernant les tailles des types :

char 8
short int 16
int 32


J'ai déclaré une structure :

Code:

---

1 2 3 4 5

struct so { short int z,y,x; int total; } So;

---

Lorsque je fais afficher sizeof(struct so), j'obtiens 12 !
Or si je compte bien : 3 * 2 octets + 1 * 4 octets = 10

Que peut-on en conclure ? Que je suis fou ?

Comment faire alors pour déclarer une structure qui ait pour types :
- 3 petits entiers tenant sur 2 octets chacun
- 1 entier sur 4 octets
pour qu'au total elle soit de 10 octets ?

oui en effet chui ok avec toi mais je pense que les deux octets en trop doivent etre du au struct .
Mais j'avoue que si quelqu'un peut dire pkoi exactement ce serait sympatoche

Je verrais bien un optimisation du compilo pour que chaque structure tienne sur 3 mots (3*4 octets). En effet il est plus rapide pour le programme de gérer des structures multiples de 32bits.

Je sais pas si c'est ca ms bon c une idée.

McFoggy.

pour vérifier

faire un

Code:

---

1 2 3 4 5

struct Toto { int toto; };

---

puis un sizeof(Toto);

verifier si il fait bien 6 octets

si oui, le sérializer dans un fichier et recommencer avec d'autres struct contenant des types différents.

et voir les octets qui sont identiques et ou ils sont placés.
(bon d'accord, ca ne nous explique pas pourquoi, mais ca permet de cerner un peu plus)


sinon essayes aussi comme ca:

Code:

---

1 2 3 4 5 6 7 8

struct Titi { short a : 16; short b : 16; short c : 16; int d : 32; };

---

je crois que c'est parceque une structure c'est une classe en C++ et qu'une classe a besoin de diverses informations (table des fonctions membres, etc ...) qui sont nécessaires au dérivations.

essaye sizeof(short int)

Code:

---

1 2 3 4 5 6

struct so { int so; int so; }

---

pèse 8 octets comme prévu

Code:

---

1 2 3 4 5 6

struct so { short so; short so; }

---

pèse 4 octets (Jusque là, tout est normal !)

Code:

---

1 2 3 4 5 6

struct so { short so; int so; }

---

pèse 8 octets (Je prends une corde ou je laisse tomber ?)

essaye ca :

Code:

---

1 2 3 4 5 6 7

struct Titi { short a : 16; short b : 16; short c : 16; int d : 32; };

---

Code:

---

1 2 3 4 5 6 7 8

struct Titi { short a : 16; short b : 16; short c : 16; int d : 32; };

---

pèse aussi 12 octets et pas 10 comme on aurait pu prévoir (16+16+16+32=80... 80/8=12 bien sûr...)

:cry:

Dans ce cas, on est a peu pres sur que ca se passe au niveau du compilo, comme McFloggy l'a dit.

C'est tres important pour ton programme, d'avoir 12 octets ou lieu de 10 ?

Si oui, peut-etre que ca se désactive dans les options de compilations.

Oui c'est très important malheureusement que ça ne pèse que 10 octets dans mon programme (et pas 12 comme le mesure C++ Builder)... Je vais regarder dans les options de compilation, mais si quelqu'un a d'autres solutions, je suis preneur !

Dans les options de compilation, essaie de désactiver les RTTI (Run Time Type Information), et essaie aussi de sélectionner la norme standard ANSI ++.

C ds les options de compilations :

Projet/Options/Options du compilateur avancées

tu mets Alignement des données sur Byte => sizeof(So) = 10

C'était bien une optimisation du compilateur.

McFoggy

Certains ont dit qu'un struct était géré comme une classe.
J'ai vu ça aussi sur le code d'un type qui bosse avec moi, ms vous êtes sur que c'est de l'ANSI ça ? C'est pas un ajout de Builder ?

McFoggy

Merci à tous;
J'avais fini par feinter puisqu'en fait cette structure servait pour lire un fichier :

je faisais

Code:

---

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

struct so { short x; short y; short z; int valeur; }   ...   fichier.read((char *)&So,sizeof(struct so));

---

Mais comme il lisait 12 octets à chaque enregistrement au lieu de 10, forcément ça marchait pas... Donc j'avais feinté en faisant :

Code:

---

1 2 3 4 5 6 7 8 9 10

short x,y,z; int valeur;   ...   fichier.read((char *)&x,2); fichier.read((char *)&y,2); fichier.read((char *)&z,2); fichier.read((char *)&valeur,4);

---

ce qui me permettait bien de récupérer 10 octets par enregistrement.

Encore merci, ça pourra toujours servir de connaitre ces options de compilation !!