Bonjour,

J'aimerais vous soumettre le probl�me suivant :

L'un des programmes que j'utilise lit des fichiers dans divers formats.

Une premi�re couche g�n�re � partir de ces fichiers, des objets temporaires qu'il passe ensuite � une seconde couche qui les v�rifie et instancie mon mod�le de donn�e.

Code : S�lectionner tout - Visualiser dans une fen�tre � part
1
2
3
fichier format A --> [Brique A] -\
fichier format B --> [Brique B] ----> Objet intermédiaire ---> [traducteur] ---> Mon Modèle
fichier format C --> [Brique C] -/
L'int�r�t de passer par cette couche interm�diaire r�side dans le fait que les diff�rents formats lus sont stables, alors que mon mod�le est sujet � variations, je n'ai donc qu'une unique brique � modifier lorsque je change mon mod�le.
Les inconv�nients sont nombreux, mais il n'en est pas question ici.

Mon probl�me est d'optimiser l'une des briques qui lit les objets temporaire.
Cette brique utilise un unique objet de chaque type, le remplit au fur et � mesure, avant de la passer � ma seconde couche.
Elle le r�initialise ensuite, puis recommen�e sa lecture.

Pour le moment, la r�initialisation est faite atomiquement, c'est � dire qu'elle ressemble � �a :
Code : S�lectionner tout - Visualiser dans une fen�tre � part
1
2
3
4
5
6
7
8
MonObjetTemporaireDeTypeCapitaine::Reinit()
{
	m_iAgeDuCapitaine = -1;
	m_fTailleDuCapitaine = -1.0F;
	m_pFemmeDuCapitaine = NULL;
	m_sNomDuCapitaine = "unamed";
	...
}
Mais je me disais que je pourrais gagner du temps en cr�ant un second objet temporaire avec mes valeurs par d�faut avec ces valeurs et le copier � chaque fois pour r�initialiser l'autre (Je pense m�me qu'il s'agit d'un DP de cr�ation).

L'id�e �tant que la copie d'un bloc de m�moire de n octets est plus rapide que la copie de n blocks de m�moire de 1 octet. Il faut donc que je veille � ce que mon constructeur par recopie utilise bien une copie d'un block.

Je peux m'en sortir en faisant quelque chose comme �a :
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
 
struct SDonneeCopiablesDuCapitaine
{
	int m_iAgeDuCapitaine;
	float m_fTailleDuCapitaine;
	Individu* m_pFemmeDuCapitaine;
};
struct SDonneeNonCopiablesDuCapitaine
{
	std::string m_sNomDuCapitaine;
};
struct SDonneesDuCapitaine
{
	SDonneeCopiablesDuCapitaine dc;
	SDonneeNonCopiablesDuCapitaine dnc;
};
struct SDonneesAlternativesDuCapitaine
{
	char dc[sizeof(SDonneeCopiablesDuCapitaine )];
	SDonneeNonCopiablesDuCapitaine dnc;
};
class MonObjetTemporaireDeTypeCapitaine
{
	union
	{
		SDonneesDuCapitaine dc;
		SDonneesAlternativesDuCapitaine dac;
	}
};
ce qui me permettrait de construire mon constructeur par recopie comme �a :
Code : S�lectionner tout - Visualiser dans une fen�tre � part
1
2
3
4
5
6
 
MonObjetTemporaireDeTypeCapitaine::MonObjetTemporaireDeTypeCapitaine(MonObjetTemporaireDeTypeCapitaine& toCopy)
{
	dac.dc = tocopy.dac.dc;		// ceci est une copie de tableau plus rapide qu'une somme de copies atomiques.
	dac.dnc = tocopy.dac.dnc ;	// ceci est une suite de copies atomiques.
}
Cette fa�on de faire est un peu p�nible car elle rend assez difficilement accessible mes donn�es, et elle semble assez peu �volutive.

Les questions que je me pose avant de commen�er � r�aliser cette optimisation sont :
- Existe-t-il une fa�on plus �l�gante de g�rer ce probl�me ?
- Est-ce seulement intelligent de le faire (peut-�tre le compilateur le fait-il pour moi sans que je le sache) ?
- Y a-t-il moyen d'automatiser la cr�ation des structures et des accesseurs en utilisant des template et des typelist. Le principal obstacle que je discerne �tant, dans un typelist : comment reconnaitre un type copiable d'un type non-copiable ?

Merci d'avoir lu.
Merci � ceux qui r�pondront.