Gestion d'un buffer dans une classe DataStream

Version imprimable

20/10/2008, 10h01
Kromagg

2 pièce(s) jointe(s)

Gestion d'un buffer dans une classe DataStream

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 :D

Naoss.

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:

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.

20/10/2008, 10h37
Alp

Citation:

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.
20/10/2008, 16h03
Kromagg

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
20/10/2008, 17h22
Sylvain Togni

Dans quel format souhaites-tu stocker les données dans ton buffer (binaire, texte, ...) ?
20/10/2008, 17h25
Kromagg

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.
20/10/2008, 18h57
Sylvain Togni
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:

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.)
20/10/2008, 19h56
Kromagg

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.
21/10/2008, 14h25
Sylvain Togni

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

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

Code:

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

22/10/2008, 16h45
Médinoc

Ne pas oublier de vérifier la taille du buffer pour éviter les débordements...
22/10/2008, 17h19
Kromagg

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 ?
22/10/2008, 17h22
Médinoc

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.
22/10/2008, 17h23
Médinoc

Mais en fait, cette classe de buffer fait beaucoup plus "vecteur" que "flux".
Dans un flux, les données devraient être stockées sérialisées...
22/10/2008, 17h48
Kromagg

Je peux utiliser boost::serialize pour faire ça ?
22/10/2008, 17h58
Médinoc

Aucune idée, je n'ai encore jamais touché à boost.
22/10/2008, 18h05
Kromagg

D'accord merci à tous j'ai maintenant de bonnes pistes pour établir mon code :)