Discussion :

[3DArchi]

Bonjour,
Voici une classe:

Code :

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

1
2
3
4
5
6
class A
{
public:
   A(const int&P_i):m_ri(P_i){}
   const int &m_ri;
};

Dès que je fait ceci:

Code :

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

1
2
3
4
5
   int L_i(0);
   A a(L_i);
 
   std::vector<A> L_vect;
   L_vect.push_back(a);

J'ai une belle erreur m'indiquant que je ne peux pas copier l'objet ("can't use default assignment operator" avec gcc et "'operator =' function is unavailable in 'A'" avec Visual).
Maintenant, je modifie 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
#include <new>
class A
{
public:
   A(const int&P_i):m_ri(P_i){}
 
   A&operator=(const A&P_Copie)
   {
      new(this) A(P_Copie);
      return *this;
   }
 
   const int &m_ri;
};

Là, ça passe.
Je comprend comme ça:
Dans l'affectation, j'appelle le constructeur par copie (créé implicitement par le compilo) sur this. Donc mes deux objets réfèrent au même objet de base. Je maintient la contrainte de const.
Est-ce bien cela? Il y a-t-il d'autres conséquences/effets de bord dont il faut que je soit conscient?
Merci.

[Médinoc]

Attention: En appelant le constructeur sur this, tu écrases un objet qui n'a pas été détruit...
Tu dois appeler le destructeur d'abord. Note que cela n'est pas exception-safe: Si une exception est lancée dans le constructeur, tu te retrouves avec un objet détruit mais pas reconstruit!

En clair: Si tu veux que ton objet soit assignable (ou même swappable), ne lui donne pas de membre référence (const ou non, ça ne change rien, car c'est la référence elle-même qui n'est pas modifiable).

C'est le genre de cas où je pense qu'utiliser un membre pointeur (const si tu veux) est une meilleure idée.

[Médinoc]

Sinon, tu peux peut-être faire un truc de ce genre :

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
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
#include <cstring>
#include <algorithm>
 
template< class T >
class SwappableReference 
{
public:
	T & ref;
	operator T& () const
	{
		return ref;
	}
	SwappableReference(T & r) : ref(r) {}
 
	void Swap(SwappableReference< T > & other)
	{
		//Cette fonction contourne la constance de la référence
		//En manipulant directement les données binaires.
		//C'est un peu comme un const_cast bien gras...
		const size_t mySize = sizeof *this;
		char bytes[ mySize ];
		std::memcpy(bytes, &other, mySize);
		std::memcpy(&other, this, mySize);
		std::memcpy(this, bytes, mySize);
	}
private:
	//On interdit quand même l'assignation:
	//Seuls la copie et le swap sont autorisés
	SwappableReference<T> & operator=(SwappableReference<T> const &);
};
 
namespace std
{
	//NOTE: La spécialisation partielle de fonction n'étant pas permise,
	//ce code ajoute une surcharge de std::swap() au lieu d'ajouter une spécialisation de template.
	//Ce n'est pas vraiment autorisé, mais il n'existe pour l'instant pas d'autre moyen.
	template< class T >
	void swap(SwappableReference< T > & left, SwappableReference< T > & right)
	{
		left.Swap(right);
	}
}
 
//--- Utilisation ---
 
class A
{
public:
	A(const int & P_i) : m_ri(P_i) {}
 
	SwappableReference<const int> m_ri;
 
	//Opérateur = redéfini avec fonction swap
	//NOTE: L'opérateur prend son paramètre par valeur et non par référence:
	//C'est pour forcer un appel au constructeur de copie.
	A & operator=(A tmp)
	{
		Swap(tmp);
		return *this;
	}
 
	void Swap(A & other)
	{
		//NOTE: On peut aussi utiliser notre surcharge de std::swap,
		//mais je préfère éviter...
		m_ri.Swap(other.m_ri);
	}
 
};
 
namespace std
{
	template<> void swap<A>(A & left, A & right) { left.Swap(right); }
}
 
//--- Test ---
#include <vector>
#include <iostream>
 
void TestReference(void)
{
	int L_i(0);
	A a(L_i);
 
	std::vector<A> L_vect;
	L_vect.push_back(a);
 
	int const & ri = L_vect[0].m_ri;
	L_i = 42;
 
	std::cout << ri << std::endl;
}

Grâce à la classe intermédiaire qui se charge du sale boulot, le code compile tout en restant exception-safe...

[3DArchi]

Effectivement, j'avais oublié le destructeur. Sur mon cas, ça ne prêtait pas à conséquence, mais dans l'absolue ça reste une c..rie.
J'aime bien ton SwappableReference mais je vais quand même réfléchir à cette histoire de pointeur. Ce sera peut être moins confus à expliquer/maintenir.
Merci.

[Médinoc]

je vais quand même réfléchir à cette histoire de pointeur. Ce sera peut être moins confus à expliquer/maintenir.

Et je plussoie: N'oublie qu'une référence indique généralement un temps de vie court: On n'est pas censé avoir à "maintenir en vie" une variable une fois que la fonction à qui on en a passé une référence a retourné (la fonction en question étant, ici, le constructeur).
Mais en fait, en suivant cette philosophie, on ne devrait jamais mettre une référence en variable membre d'une classe...

[3DArchi]

En fait, j'avais mis une référence car j'avais deux listes liées: une première map contenant des éléments, et un vecteur de propriétés. Les propriétés maintiennent une référence vers l'élément concerné. Donc les deux durées de vie sont liées. Mais, bon, je me rends compte que ça complique plus que ça ne clarifie/sécurise. Donc, je crois que je vais passer sur le pointeur.

[loufoque]

Ou alors tu pourrais utiliser boost::reference_wrapper<T> au lieu de T&.

[JolyLoic]

Mais en fait, en suivant cette philosophie, on ne devrait jamais mettre une référence en variable membre d'une classe...

Ca m'arrive régulièrement de le faire, pour des classes non copiables, bien sur et généralement des classes servant à implémenter le RAII. Ce qui rejoint l'idée de temporaire...

[Médinoc]

En effet...
Je m'en sers aussi pour certaines classes RAII.