Discussion :

[babar63]

Bonjour � tous,
Je suis actuellement dans la lecture d'un excellent bouquin sur la programmation de jeu, une partie traite des classes optionnelles voila un bout du code :

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
31
32
33
// Base :
template <unsigned long size>
class optional_base
{
public:
	optional_base();
	optional_base(const optional_base &t);
 
	optional_base & operator = (const optional_base &t);
 
	bool const Valid() const;
	bool const UnValid() const;
 
protected:
	bool m_bValid;
	char m_data[size];
};
 
// Optional :
template <class T>
class optional : public optional_base<sizeof(T)>
{
public:
 
	// Constructeurs...
	// Operateurs...
private:
 
	const T * const GetT() const	{ return reinterpret_cast<const T * const>(m_data); }
	T * const GetT()		{ return reinterpret_cast<T * const>(m_data); }
	void Construct(const T &t)	{ new (GetT()) T(t); }
	void Destroy()			{ GetT()->~T(); }
};

Seulement c'est la premi�re fois que je vois l'op�rateur new utilis� de cette mani�re, il n'y a de delete associ� nulle part dans le code et GetT dans ce cas retourne un T*const donc les donn�es ne sont pas senc� �tre modifi� sauf si j'ai rien compris....... Si vous pouviez m'�clairer sur ce myst�re , si il faut plus de d�tail sur le code n'h�sitez pas � demander
Merci d'avance

[Mat007]

Salut,

C'est un placement new, cf. cette entr�e de la FAQ.
Un new "normal" est s�par� en deux : allocation de la m�moire et initialisation, un placement new (comme son nom l'indique un peu) se contente d'effectuer la partie initialisation (donc d'appeler le constructeur en gros).

edit : il y a une ) en trop dans le corps de Construct a priori.

MAT.

[MatRem]

Si la m�thode retourne un T * const, alors c'est le pointeur qui est constant, pas la donn�e point�e .

C'est d'ailleurs parceque la donn�e retourn�e peut �tre modifi�e que la fonction elle m�me n'est pas const.

[babar63]

il y a une ) en trop dans le corps de Construct a priori

Petite faute d'inattention c'est r�gl�... Merci beaucoup pour le lien sur la faq je l'avais loop� . En tout cas tout est limpide d�sormais concernant la syntaxe

Si la m�thode retourne un T * const, alors c'est le pointeur qui est constant, pas la donn�e point�e

A vrai dire je ne me suis jamais vraiment pos� la question pour moi "const T *" �tait associ� � un pointeur constant et du coup "const T * const" � un pointeur constant sur donn�e constante(d'apr�s ma logique ) Mais alors ce que je comprend pas c'est pourquoi utiliser ces deux syntaxes pour d�finir la m�me chose mais surtout pourquoi mettre deux 'const' sachant que l'un d'entre eux ne veut strictement rien dire....
En tout cas merci beaucoup pour votre aide

Edit : Finalement le compilateur ne semble pas appr�cier sans les parenth�se donc en fait il en manquait une je suppose, pour compiler :

Code :

S�lectionner tout - Visualiser dans une fen�tre � part

new (GetT()) T(t);

[droggo]

Wue,

alors ce que je comprend pas c'est pourquoi utiliser ces deux syntaxes pour d�finir la m�me chose mais surtout pourquoi mettre deux 'const' sachant que l'un d'entre eux ne veut strictement rien dire....

Attention : un pointeur constant signifie qu'on ne peut pas le modifier, n'est pas la m�me chose que "donn�es point�es constantes".

Par exemple, avoir un pointeur constant n'interdit absolument pas de modifier les donn�es point�es, SAUF si elles-m�mes sont d�clar�es constantes.

[MatRem]

Pour �tre tout � fait pr�cis sur la constance avec les pointeurs :

La donn�e et le pointeur sont constants :
const T * const ou T const * const

ex :

Code :

S�lectionner tout - Visualiser dans une fen�tre � part

1
2
3
4
5
6
7
8
int i, j;
int const * const p_i = &i;
 
//on ne peut pas modifier i à partir de  p_i
//*p_i = 10 interdit
 
//on ne peut pas modifier p_i
//p_i = &j interdit

La donn�e est constante mais pas le pointeur :
const T * ou T const *
ex :

Code :

S�lectionner tout - Visualiser dans une fen�tre � part

1
2
3
4
5
6
7
8
int i, j;
int const * p_i = &i;
 
//on ne peut pas modifier i à partir de  p_i
//*p_i = 10 interdit
 
//on peut modifier p_i
p_i = &j; //ok

Le pointeur est constant mais pas la donn�e :
T * const
ex :

Code :

S�lectionner tout - Visualiser dans une fen�tre � part

1
2
3
4
5
6
7
8
int i, j;
int * const p_i = &i;
 
//on peut modifier i à partir de  p_i
*p_i = 10; //ok
 
//on ne peut pas modifier p_i
//p_i = &j interdit

Pour faciliter la m�morisation de ce qui est constant, le mieux est de tojours utiliser la syntaxe const apr�s (T const * const), puisque pour les pointeurs constants c'est oblig�.
Dans ce cas ce qui est constant se situe avant le const.
Et puis cette r�gle n'induit pas vraiment en erreur dans le cas ou on utilise le const avant (const T * const) puisqu'on voit vite qu'il n'y a rien avant.


La en parle

[MatRem]

Et pour ce qui est des fonctions membres const :
une fonction membres const ne doit pas modifier ou permettre de modifier l'instance � laquelle elle appartient (il y a un cas particulier avec le mot clef mutable).
Et donc en cons�quence, seul les fonctions membres const pourront �tre appell�es sur les objets constant.

ex:

Code :

S�lectionner tout - Visualiser dans une fen�tre � part

1
2
3
4
 
optional<int> const opt;
opt.GetT(); //l'objet opt est constant, c'est donc la fonction déclarée const qui sera utilisée, et le pointeur retournée sera int const * const;
//Si seule la fonction non const avait été déclarée, la compilation ne serait pas passée.

Il y a donc une r�elle diff�rence entre les deux fonctions :

Code :

S�lectionner tout - Visualiser dans une fen�tre � part

1
2
3
 
const T * const GetT() const;
T * const GetT();

Les 2 renvois un pointeurs constant vers une donn�e membre de l'instance (m_data).
Mais la premi�re renvois un pointeur constant sur donn�e constante, il ne permet donc pas de modifier m_data.
La deuxi�me version le permet.

C'est pourquoi la premi�re fonction peut �tre d�clar�e const.


La en parle

[babar63]

Vu de ce cot� tout est logique en fait je confondais "const T *" et "T * const". C'est la raison pour laquelle je ne saisissais pas le code puisque pour moi la donn�e ne pouvait pas �tre modifi� . C'est vrai que dans ce cas il est pr�f�rable d'utiliser const apr�s pour mieux de compr�hension... Encore merci pour vos r�ponses claires et pr�cises qui m'ont permis d'y voir plus clair sur ce point

[corrector]

Si la m�thode retourne un T * const, alors c'est le pointeur qui est constant, pas la donn�e point�e .

On ne peut pas renvoyer un scalaire constant en C++. Dans :

Code :

S�lectionner tout - Visualiser dans une fen�tre � part

const int f ();

le const est tout simplement ignor�, comme dans :

Code :

S�lectionner tout - Visualiser dans une fen�tre � part

void f (const int i);

[corrector]

Je suis actuellement dans la lecture d'un excellent bouquin

Bof...

Code :

S�lectionner tout - Visualiser dans une fen�tre � part

1
2
3
4
5
6
7
8
9
10
11
12
 
template <unsigned long size>
class optional_base
{
	char m_data[size];
};
 
template <class T>
class optional : public optional_base<sizeof(T)>
{
	void Construct(const T &t)	{ new (GetT()) T(t); }
};

Qu'est-ce qui va garantir l'alignement de m_base? Comment ce code peut avoir la moindre chance de marcher?

[babar63]

Il s'agit de Game Coding Complete (Second Edition). Et oui je confirme le livre est excellent , m�me si il est possible de trouver quelques erreur de code sur presque 900 pages je pense que ce code a du marcher d'une mani�re ou d'une autre, il est pr�sent� comme un des outils dont utilis� l'auteur (enfin la je m'avance un peu )... Pour en revenir � l'alignement peut �tre quelque chose ma �chapp� mais n'est-il pas possible de le d�sactiver simplement?

EDIT : En fait c'est stupide le sizeof en revanche garantit bien l'alignement...

[corrector]

Il s'agit de Game Coding Complete (Second Edition). Et oui je confirme le livre est excellent , m�me si il est possible de trouver quelques erreur de code sur presque 900 pages je pense que ce code a du marcher d'une mani�re ou d'une autre

Sur certains processeur les acc�s non align�s sont "seulement" beaucoup plus lents. (Pour des jeux c'est f�cheu.)

(enfin la je m'avance un peu )... Pour en revenir � l'alignement peut �tre quelque chose ma �chapp� mais n'est-il pas possible de le d�sactiver simplement?

C'est une caract�ristique du processeur.

EDIT : En fait c'est stupide le sizeof en revanche garantit bien l'alignement...

Pardon?

[babar63]

Voila ce que je pense : Les donn�es de l'objet T est repr�sent� par un tableau de char, par d�faut cette structure est align�e, et la taille du tableau devrait �tre correct puisqu'on utilise sizeof(T). Quand je disais qu'il garantissait bien l'alignement je voulais dire que le reinterpret_cast fonctionnerait (du moins je pense...). Pour ce qui est du placement new c'�tait le sujet du topic donc forc�ment je ne vais pas trop m'avancer mais j'ai cru comprendre que c'�tait simplement l'appel au constructeur de l'objet (l'allocation �tant d�j� effectu�), le pointeur sur la zone �tant valide et la taille correct je ne vois pas d'o� vient le probl�me... Peut-tu me dire sur quel point je me trompe?

EDIT : En relisant plus correctement la faq c'est vrai qu'il est bien pr�ciser que l'objet doit �tre correctement align� pour utiliser le placement new, donc si c'est le cas aucun probl�me pour le code je suppose? Par d�faut le compilateur aligne bien non? il y aurait donc danger seulement si on "trafique" l'alignement? ...Dites moi si j'ai tout faux

EDIT2 : En tout cas je crois que je vais devoir r�viser mes cours, r�guler mon optimisme sur le livre et faire des tests histoire de mieux comprendre

[corrector]

Voila ce que je pense : Les donn�es de l'objet T est repr�sent� par un tableau de char, par d�faut cette structure est align�e,

Pourquoi le serait-elle?

et la taille du tableau devrait �tre correct puisqu'on utilise sizeof(T).

Ce n'est pas le probl�me. C'est l'alignement qui est en cause.

Quand je disais qu'il garantissait bien l'alignement je voulais dire que le reinterpret_cast fonctionnerait (du moins je pense...).

Au del� du reinterpret_cast (qui sur les archi courantes "fonctionne" toujours), il faut pouvoir construire et manipuler un objet � cette adresse, sans g�n�rer un segfault ou �quivalent.

Pour ce qui est du placement new c'�tait le sujet du topic donc forc�ment je ne vais pas trop m'avancer mais j'ai cru comprendre que c'�tait simplement l'appel au constructeur de l'objet (l'allocation �tant d�j� effectu�),

C'est exactement �a.

le pointeur sur la zone �tant valide et la taille correct je ne vois pas d'o� vient le probl�me...

Le probl�me vient de ce que le pointeur n'est pas valide, car non-align�.

Peut-tu me dire sur quel point je me trompe?

Sur le fait que l'alignement est un "non-probl�me". (M�fiez-vous des "non-probl�mes".)

Par d�faut le compilateur aligne bien non? il y aurait donc danger seulement si on "trafique" l'alignement? ...Dites moi si j'ai tout faux

Selon la norme, tu as tout faux.

Apr�s, je ne sais pas ce que fait "par d�faut" ton compilateur.

[JolyLoic]

le const est tout simplement ignor�, comme dans :

Code :

S�lectionner tout - Visualiser dans une fen�tre � part

void f (const int i);

Ce n'est pas tout � fait vrai. Vue de l'ext�rieur, cette fonction est effectivement identique � si on avait d�clar�

Code :

S�lectionner tout - Visualiser dans une fen�tre � part

void f (int i);

Mais vue de l'int�rieur, i est une variable constante, ce qui ne serait pas le cas sinon (ce serait juste une variable dont les modifications ne seraient pas visible du code appelant).

[Garulfo]

le const est tout simplement ignor�, comme dans :

Code :

S�lectionner tout - Visualiser dans une fen�tre � part

void f (const int i);

Comme le dit JolyLoic, c'est faux ce que tu dis. Si tu essaies de compiler ceci

Code cpp :

S�lectionner tout - Visualiser dans une fen�tre � part

1
2
3
4
5
int identite (const int i)
{
   i = 1 ;
   return i ;
}

Tu obtiens une erreur � la compilation. En fait, il serait intelligent d'en mettre r�guli�rement. Cela rajoute une s�curit� suppl�mentaire.

[corrector]

Comme le dit JolyLoic, c'est faux ce que tu dis. Si tu essaies de compiler ceci

Code cpp :

S�lectionner tout - Visualiser dans une fen�tre � part

1
2
3
4
5
int identite (const int i)
{
   i = 1 ;
   return i ;
}

Tu obtiens une erreur � la compilation.

Il ne faut pas plus lire dans ce que j'ai �cris que ce que j'ai �cris :

Code :

S�lectionner tout - Visualiser dans une fen�tre � part

int identite (const int i);

est synonyme de

Code :

S�lectionner tout - Visualiser dans une fen�tre � part

int identite (int i);

Dans une d�finition de fonction, �a n'est pas �quivalent �videmment.

En fait, il serait intelligent d'en mettre r�guli�rement. Cela rajoute une s�curit� suppl�mentaire.

Je ne suis pas s�r : est-ce que ce genre d'erreurs se arrive vraiment?

[babar63]

Alors je suppose que le code provenant du livre se bas� uniquement sur des structures de base align�s c'est vrai qu'il y � une partie juste avant sur l'utilisation de la m�moire et l'importance de l'alignement dans les jeux �aE ne doit pas �tre un hasard... En revanche tr�s dommage de donner le code sans plus d'avertissement

Y � t-il une explication au fait que la structure doit �tre align�e pour appel� le new placement? Si vous connaissez des bonnes documentations sur internet traitant de �� je suis preneur

Merci beaucoup pour ton aide corrector

EDIT : Apr�s quelques tests sur visual 2005 (32bits) voil� le r�sultat :

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
struct MyStruct1
{
	char c;
	int i;
	char c2;
};
 
#pragma pack( push, 1 )
 
struct MyStruct2
{
	char c;
	int i;
	char c2;
	char unused[2];
};
 
#pragma pack( pop )
 
int main(int argc, char *argv[])
{
	cout << "size of MyStruct1 :" << sizeof(MyStruct1)*8 << endl;
	cout << "size of MyStruct2 :" << sizeof(MyStruct2)*8 << endl;
 
	system( "pause" );
	return 0;
}

Resultat :

size of MyStruct1 :96
size of MyStruct2 :64

Conclusion : le compilateur aligne mais pas de mani�re optimal

[corrector]

Alors je suppose que le code provenant du livre se bas� uniquement sur des structures de base align�s

Je ne comprends pas ce que veux dire.

... En revanche tr�s dommage de donner le code sans plus d'avertissement

Je ne dirais pas le contraire.

Y � t-il une explication au fait que la structure doit �tre align�e pour appel� le new placement?

Tout simplement parce qu'un acc�s � une donn�e, mettons � une adresse A, ne peut �tre fait que si cette donn�e peut effectivement �tre stoqu�e � l'adresse A.

Merci beaucoup pour ton aide corrector

Je t'en prie.

EDIT : Apr�s quelques tests sur visual 2005 (32bits) voil� le r�sultat :

Code :

S�lectionner tout - Visualiser dans une fen�tre � part

1
2
3
4
5
6
struct MyStruct1
{
	char c;
	int i;
	char c2;
};

Le calcul est simple (m(n) �tant le n-i�me membre, partant de 0, N le nombre de membres) :
offset(m(0)) = 0
offset(m(n+1)) = min { x tq x >= offnext(m(n)) et x mod alignof(m(n+1)) = 0 }
offnext(m(n)) = offset(m(n)) + sizeof(m(n))

Comme vous pouvez le voir, offnext(m(n)) est l'offset de la premi�re place disponible dans la structure apr�s le membre m(n).

Soit structure(m) la structure dont les membres sont les m(n) :

alignof(structure(m)) = PPCM(alignof(m(n))) (pour 0<=n<N)
sizeof(structure(m)) = min { x tq x >= offnext(m(N)) et x mod alignof(structure(m)) = 0 }

Puisque les alignements sont des puissances de 2, on a:
PPCM(alignof(m(i))) = max(alignof(m(i)))
et donc
alignof(structure(m)) = max(alignof(m(i)))

La d�finition de sizeof(structure(m)) �quivaut � ajouter � la structure un membre qui serait la structure elle-m�me, apr�s son dernier membre, et � calculer l'offset de ce membre invent�, formellement :

soit m' tq
m'(n) = m(n) (pour 0<=n<N)
m'(N) = structure(m)
et
s'(m) = structure(m')

on voit que sizeof(structure(m)) = offset(m'(N))

(J'esp�re ne pas m'�tre emm�l� dans mes notations.)

Ce qui nous donne :

Code :

S�lectionner tout - Visualiser dans une fen�tre � part

1
2
3
4
5
6
membre type  taille alignement offset offnext
c      char  1      1          0      1
i      int   4      4          4      8
c2     char  1      1          8      9
 
invent MyStruct1    4          12

(invent est le membre invent�)
(D�sol�, je ne sais pas comment faire un vrai tableau.)

Finalement :
alignof(MyStruct1) = 4
sizeof(MyStruct1) = 12

Code :

S�lectionner tout - Visualiser dans une fen�tre � part

1
2
3
4
5
6
7
8
9
10
11
#pragma pack( push, 1 )
 
struct MyStruct2
{
	char c;
	int i;
	char c2;
	char unused[2];
};
 
#pragma pack( pop )

Je suppose qu'on d�fini un alignement de 1. C'est � dire que le compilateur n'aligne plus rien, �a ne veut pas dire que le processeur va changer d'avis sur l'alignement.

Code :

S�lectionner tout - Visualiser dans une fen�tre � part

1
2
3
4
5
6
7
8
int main(int argc, char *argv[])
{
	cout << "size of MyStruct1 :" << sizeof(MyStruct1)*8 << endl;
	cout << "size of MyStruct2 :" << sizeof(MyStruct2)*8 << endl;
 
	system( "pause" );
	return 0;
}

Resultat : Conclusion : le compilateur aligne mais pas de mani�re optimal

Pourquoi pas optimale? Tu peux pr�ciser ce qui ne va pas?

Et pourquoi donner les r�sultats en bits en pas en octets?

[babar63]

Les deux structures crees devaient stocker deux char et un int, dans le premier cas, en laissant le compilateur aligner, la taille de la structure est de 96bits. Dans le second cas en alignant moi-meme(char unused) j'obtiens 64bits, c'est pour ca que j'ai dit que le compilateur n'alignait pas de maniere optimale... si je remplace la premiere structure :

Code :

S�lectionner tout - Visualiser dans une fen�tre � part

1
2
3
4
5
6
struct MyStruct1
{
        char c;
        char c2;
        int i;
};

La taille passe a 64bits...

Pourquoi en bit... je travaille sur une platforme 32bits et a moins d'avoir rien compris une structure alignee signifie que la taille est multiple de 32bits...voila pourquoi, je me trompe?

NOTE : C'est vrai que les notations donne mal au crane mais le tableau aide bien encore merci de te donner autant de mal

NOTE : Desole pour les accents je suis sur qwerty