vector d'object struct de taille variable

Bonjour,

bon je sais pas si le titre dit bien ce que je veux...

En fait, j'ai une structure du type :

Code:

---

1 2 3 4 5

struct message{ int longueur_message; unsigned char *data: }

---

Donc, 'longueur_message' désigne le nombre de 'unsigned char' du message...

Et donc, je voudrais savoir si je pouvais mettre ça dans un std::vector??
c'est à dire faire un std::vector<message>??


Merci à vous

Attention, ceci n'est pas une structure à taille variable.
C'est seulement une structure avec un pointeur vers un buffer, et c'est le buffer lui-même qui a une taille variable.

Quant aux vraies structures à taille variable, il est de toute façon impossible de les utiliser "par valeur", elles ne peuvent donc pas être mises dans un vecteur.

Citation:

---

Envoyé par Médinoc

Attention, ceci n'est pas une structure à taille variable.
C'est seulement une structure avec un pointeur vers un buffer, et c'est le buffer lui-même qui a une taille variable.

Quant aux vraies structures à taille variable, il est de toute façon impossible de les utiliser "par valeur", elles ne peuvent donc pas être mises dans un vecteur.

---

Euh, oui,
d'accord, ce n'est pas une structure à taille variable...
mais je savais pas trop comment dire...

Donc, devrait pas y avoir de souci pour mettre cette structure dans un vector??

'devrait pas.

Attention aux histoires de pointeur, par contre.

ouki,
merci

j'vais essayer de faire attention;)
mais j'ai pas trop l'habitude:?
en plus, là, je dois implémenter une librairie C (d'où les structures un peu sioux...)

Il y a beaucoup plus sioux que ça comme structures: Les vraies structures à taille variable.

Encore plus marrant si on y ajoute un comptage de références (comme pour l'implémentation de la classe CString de MFC, par exemple, et sa structure/classe CStringData...)

Pour mettre directement dans un std::vector tu peux utiliser un constructeur :

Code:

---

1 2 3 4

message mon_message; ... std::vector<unsigned char> mon_vecteur(mon_message.data, mon_message.data + mon_message.longueur_message); ...

---

cf l'avant dernier constructeur.

Question bête : pourquoi dans ton code C++, tu ne maintiens pas ton buffer dans un std::vector<unsigned char>. Et quand tu veux le passer à ton interface C, tu fais simplement un &[0] :

Code:

---

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

struct message{ int const longueur_message; unsigned char * const data; };   // et std::vector<unsigned char> buffer; // wrap vers le code C : message msg = { buffer.size(), &(buffer[0]) }; fonction_c(&msg);

---

Citation:

---

Il y a beaucoup plus sioux que ça comme structures: Les vraies structures à taille variable.

---

Tu aurais un lien à conseiller là-dessus ? C'est la première fois que j'en entends parler, j'ai googlé un peu mais sans succès (et conceptuellement, j'ai du mal avec l'idée).

Typiquement, c'est une structure avec un tableau à la fin, dont on ajuste la taille quand on alloue.

Exemple:

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22

#include <stddef.h> /*pour offsetof()*/ #include <stdlib.h>   struct TableauDeInt { size_t taille; int data[1]; };   struct TableauDeInt *AllocTableauDeInt(size_t taille) { struct TableauDeInt *ret = NULL; size_t cbAvantData = offsetof(struct TableauDeInt, data); size_t cbData = taille * sizeof (ret->data[0]); /*Note: ret n'est pas vraiment déréférencé, grace au sizeof*/ size_t cbTotal = cbAvantData + cbData; ret = malloc(cbTotal); if(ret != NULL) { ret->taille = taille; } return ret; }

---

Ca vient surtout du C où ca peut être très utile pour des messages de taille variable (comme le titre l'indique) : typiquement échange réseau : la taille au début suivi des données. Tu n'as qu'un seul bloc d'alloué pour la lecture/réception. En fait, l'intérêt est là: ta structure est une en-tête + des données : les deux se suivent en mémoire. Il n'y a pas d'indirection.