Discussion :

[germinolegrand]

Bonsoir !

J'ai créé une union, et j'ai maintenant besoin de définir un operator=(&&), voici la première chose qui m'est passée par la tête :

Code :

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

1
2
3
4
5
6
auto Parser::ParseResult::operator=(ParseResult&& other) -> ParseResult&
{
    (*this).~ParseResult();
    new (this) ParseResult(std::move(other));
    return *this;
}

Sachant qu'à priori, ni le destructeur ni le constructeur par déplacement ne peuvent balancer d'exception (destruction/déplacement soit de std::string, soit de shared_ptr, soit de types primitifs).

Quelles critiques peut-on adresser à une telle implémentation ? D'une part dans ce cas précis, d'autre part dans un cas plus général ?

Si vous avez besoin d'un code plus complet, je peux éventuellement essayer d'extraire les parties pertinentes.

Merci d'avance pour vos réponses !

[jo_link_noir]

> Quelles critiques peut-on adresser à une telle implémentation ? D'une part dans ce cas précis, d'autre part dans un cas plus général ?

Que c'est une très mauvaise idée. mon_resultat = std::move(mon_resultat) si ne plante pas va tout de même supprimer les valeurs.
Alors oui, c'est facile à voir dans cet exemple. Mais quand l'opérante de gauche est une référence sur mon_resultat, c'est beaucoup plus compliqué.

Dans le cas général, je préfère l'implémentation par défaut (= default). Pareil pour le constructeur de mouvement. D'une part pour ne pas oublier noexcept (le compilateur le fera) et d'autre part parce qu'il y a rarement besoin de faire quelque chose. Si j'ai besoin de "déplacer" une valeur primitif plutôt que seulement la copier, je wrap le type dans une classe qui va s'en occuper.

Un truc 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
30
31
32
33
34
35
36
37
 
template<class T, class U>
T exchange(T& old_value, U && new_value)
{
  T ret{std::move(old_value)};
  old_value = std::forward<U>(new_value);
  return ret;
}
 
template<class T>
struct reset_when_move
{
  reset_when_move() = default;
  // eventuellement reset_when_move() noexcept : x_{} {}
 
  reset_when_move(reset_when_move const &) = default;
 
  reset_when_move(T x) noexcept : x_(x) {}
 
  reset_when_move(reset_when_move && other) noexcept
  : x_(exchange(other.x_, T{}))
  {}
 
  reset_when_move & operator = (reset_when_move const &) = default;
 
  reset_when_move & operator = (reset_when_move && other) noexcept
  {
    x_ = exchange(other.x_, T{});
    return *this;
  }
 
  operator T & () noexcept { return x_; }
  operator T const & () const noexcept { return x_; }
 
private:
  T x_;
};

[Médinoc]

Si tu tiens à réutiliser du code, tu peux, plutôt que cette horreur, réutiliser le swap() de ton implémentation du copy-and-swap.