Gestion d'un buffer dans une classe DataStream

**Kromagg** · 20/10/2008, 10h01

Bonjour à tous

Je voudrais réaliser une classe Buffer dont le rôle est de contenir n'importe quelle données. Ce buffer est ensuite encapsulé dans une classe DataStream, elle même transmise sur un réseau.

Vous trouverez-ci joint le code source de ma classe Buffer, incomplète pour le moment.

J'aimerai simplement savoir si je me dirige dans la bonne voie, et aussi qu'elles fonctionnalité vous ajouteriez

Merci d'avance

Naoss.

**3DArchi** · 20/10/2008, 10h34

Bonjour,
1/Dans Buffer::Buffer(), autant utiliser mSize pour l'allocation plutôt que MAX_BUFFER_SIZE.
2/ Dans Buffer::Buffer(char*..) et Buffer::Buffer(const Buffer&), tu fait l'assert après le memcpy. Imprudent...
3/ operator=: Afin d'éviter d'avoir un objet incorrect (par exemple suite à l'échec de l'allocation après avoir libéré mData), en général l'opérateur = va plutôt fonctionner comme ça:

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
Buffer& Buffer::operator = (const Buffer& _rhs)
{
   Buffer tmp(_rhs);
   swap(*this,tmp);
   return *this;
}
void Buffer:swap(Buffer& _rhs)
{
   std::swap(mSize,_rhs.mSize);
   std::swap(mPosition,_rhs.mPosition);
   std::swap(mData,_rhs.mData);
}

4/ Dans setSize, tu va avoir un problème si la nouvelle taille est plus grande que l'ancienne. En effet, à ce moment tempData est de taille plus petite que la nouvelle valeur de mSize.
5/ En général, on met::operator << en fonction externe à la classe.

**Alp** · 20/10/2008, 10h37

Envoyé par 3DArchi

5/ En général, on met::operator << en fonction externe à la classe.

Qui fait en général appel à une fonction "print" ou "afficher" qui est elle membre de la classe, et éventuellement virtuelle. On peut ainsi faire un operator<< polymorphique pour cette hiérarchie de classe.

**Kromagg** · 20/10/2008, 16h03

Ok merci maintenant mon souci c'est que je ne sais pas trop comment remplir mon buffer.

Je voudrais faire une seule fonction, en l'occurrence operator << avec en paramètre mes données (de type template<class T>) à mettre dans mon buffer
Je ne connais pas la méthode pour faire ceci de façon correcte.

Pourriez vous simplement m'indiquer la procédure ?

Naoss

**Sylvain Togni** · 20/10/2008, 17h22

Dans quel format souhaites-tu stocker les données dans ton buffer (binaire, texte, ...) ?

**Kromagg** · 20/10/2008, 17h25

Est bien binaire me semble plus rapide mais le problème c'est que je veux stocker n'importe quel type d'information : vecteur... et en binaire, une fois que je veux lire le contenu de mon buffer c'est peut être plus galère.

**Sylvain Togni** · 20/10/2008, 18h57

En format texte c'est simple il suffit d'utiliser std::stringstream.

En binaire par contre soit tu utilise une bibliothèque tierce (boost::serialize par exemple) soit tu le fais toi même mais ça demande un peu de boulot. Il faut commencer par définir le format de stockage pour chaque type de données. Mais la encore, quitte à avoir besoin d'un format autan utiliser un format existant, comme XDR par exemple.

Pas de solution toute simple à base de template en tout cas, sauf à faire quelque chose comme

Code :

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

1
2
3
4
5
6
template<typename T>
DataStream& operator<<(DataStream& dst, T const& src)
{
  dst.append(reinterpret_cast<char const*>(&src), sizeof(src));
  return dst;
}

mais cela ne marchera qu'avec des POD, et la lecture ne fonctionnera que sur la même architecture, avec le même compilateur et les même options de compilations. (Dans certains cas cette solution peut suffire.)

**Kromagg** · 20/10/2008, 19h56

Quand je parle de DataStream je veux dire que par là que c'est une classe qui contient un buffer dans lequel sont stockés des informations de n'importe quel type. Tout ceci est en mémoire est aucun fichier n'intervient.

**Sylvain Togni** · 21/10/2008, 14h25

Pas de fichiers d'accord mais tu as parler de transmission réseau, non ? Donc potentiellement vers une machine différente.

**Kromagg** · 22/10/2008, 16h38

Je voudrais savoir si avec ce genre de code je peux généraliser mon buffer :

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
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
 
template<class T>
class Buffer
{
private:
 
	T* mData;
 
	int mPosition;
 
	int mSize;
 
public:
 
	void writeData(const T& _data)
	{
		mData[mPosition++] = _data;
	}
 
	void readData(T* _buffer, int _position, size_t _sizeToRead);
	{
		int nb = _sizeToRead / sizeof(T);
		for(int i = _position; i <= _position + nb; i++)
		{
			int j = 0;
			_buffer[j] = mData[i];
			j++;
		}
	}
};

**Médinoc** · 22/10/2008, 16h45

Ne pas oublier de vérifier la taille du buffer pour éviter les débordements...

**Kromagg** · 22/10/2008, 17h19

Merci Médinoc, mais à part ça est-ce que ce code est valable?
Marche-t-il pour les types de bases ?
Marche-t-il pour une classe ?

**Médinoc** · 22/10/2008, 17h22

Je dirais qu'il marche pour tout ce qui est copiable, mais tu devrais supprimer toute notion de bytes. En clair, remplacer sizeToRead par numberOfElementsToRead.