Discussion :

[melleb]

Bonjour,

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

En fait, j'ai une structure du type :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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

[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.

[melleb]

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??

[Médinoc]

'devrait pas.

Attention aux histoires de pointeur, par contre.

[melleb]

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...)

[Médinoc]

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...)

[hiura]

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

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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.

[3DArchi]

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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);

[white_tentacle]

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).

[Médinoc]

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

Exemple:

Code C :

Sélectionner tout - Visualiser dans une fenêtre à part

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;
}

[3DArchi]

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.