Est-ce un piège connu de C ++ 11 pour les boucles?

Imaginons que nous ayons une structure pour contenir 3 doubles avec des fonctions membres:

struct Vector {
  double x, y, z;
  // ...
  Vector &negate() {
    x = -x; y = -y; z = -z;
    return *this;
  }
  Vector &normalize() {
     double s = 1./sqrt(x*x+y*y+z*z);
     x *= s; y *= s; z *= s;
     return *this;
  }
  // ...
};

C'est un peu artificiel pour la simplicité, mais je suis sûr que vous êtes d'accord pour dire qu'un code similaire existe. Les méthodes vous permettent d'enchaîner facilement, par exemple:

Vector v = ...;
v.normalize().negate();

Ou même:

Vector v = Vector{1., 2., 3.}.normalize().negate();

Maintenant, si nous avons fourni les fonctions begin () et end (), nous pourrions utiliser notre Vector dans un nouveau style for loop, disons pour faire une boucle sur les 3 coordonnées x, y et z (vous pouvez sans doute construire plus d'exemples "utiles" en remplaçant Vector par eg String):

Vector v = ...;
for (double x : v) { ... }

On peut même faire:

Vector v = ...;
for (double x : v.normalize().negate()) { ... }

et aussi:

for (double x : Vector{1., 2., 3.}) { ... }

Cependant, ce qui suit (il me semble) est cassé:

for (double x : Vector{1., 2., 3.}.normalize()) { ... }

Bien que cela semble être une combinaison logique des deux utilisations précédentes, je pense que cette dernière utilisation crée une référence pendante alors que les deux précédentes sont tout à fait correctes.

• Est-ce correct et largement apprécié?
• Quelle partie de ce qui précède est la "mauvaise" partie, qui devrait être évitée?
• Le langage serait-il amélioré en modifiant la définition de la boucle for basée sur la plage de sorte que les temporels construits dans l'expression for existent pendant la durée de la boucle?

Est-ce correct et largement apprécié?

Oui, votre compréhension des choses est correcte.

Quelle partie de ce qui précède est la "mauvaise" partie, qui devrait être évitée?

La mauvaise partie prend une référence de valeur l à un temporaire renvoyé par une fonction et la lie à une référence de valeur r. C'est aussi grave que ça:

auto &&t = Vector{1., 2., 3.}.normalize();

La Vector{1., 2., 3.}durée de vie du temporaire ne peut pas être étendue car le compilateur n'a aucune idée que la valeur renvoyée par lui fait normalizeréférence.

Le langage serait-il amélioré en modifiant la définition de la boucle for basée sur la plage de sorte que les temporels construits dans l'expression for existent pendant la durée de la boucle?

Ce serait très incompatible avec le fonctionnement de C ++.

Cela empêcherait-il certains pièges faits par des personnes utilisant des expressions chaînées sur des temporaires ou diverses méthodes d'évaluation paresseuse pour les expressions? Oui. Mais cela nécessiterait également du code de compilateur dans des cas spéciaux, ainsi que la raison pour laquelle il ne fonctionne pas avec d' autres constructions d'expression.

Une solution beaucoup plus raisonnable serait un moyen d'informer le compilateur que la valeur de retour d'une fonction est toujours une référence à this, et par conséquent, si la valeur de retour est liée à une construction à extension temporaire, elle étendrait le temporaire correct. C'est une solution au niveau de la langue.

Actuellement (si le compilateur le prend en charge), vous pouvez faire en sorte qu'il normalize ne puisse pas être appelé sur un temporaire:

struct Vector {
  double x, y, z;
  // ...
  Vector &normalize() & {
     double s = 1./sqrt(x*x+y*y+z*z);
     x *= s; y *= s; z *= s;
     return *this;
  }
  Vector &normalize() && = delete;
};

Cela entraînera Vector{1., 2., 3.}.normalize()une erreur de compilation, alors que v.normalize()cela fonctionnera correctement. De toute évidence, vous ne pourrez pas faire des choses correctes comme celle-ci:

Vector t = Vector{1., 2., 3.}.normalize();

Mais vous ne pourrez pas non plus faire de mauvaises choses.

Alternativement, comme suggéré dans les commentaires, vous pouvez faire en sorte que la version de référence rvalue renvoie une valeur plutôt qu'une référence:

struct Vector {
  double x, y, z;
  // ...
  Vector &normalize() & {
     double s = 1./sqrt(x*x+y*y+z*z);
     x *= s; y *= s; z *= s;
     return *this;
  }
  Vector normalize() && {
     Vector ret = *this;
     ret.normalize();
     return ret;
  }
};

Si Vectorétait un type avec des ressources réelles à déplacer, vous pouvez utiliser à la Vector ret = std::move(*this);place. L'optimisation de la valeur de retour nommée rend cela raisonnablement optimal en termes de performances.

pour (double x: Vector {1., 2., 3.}. normalize ()) {...}

Ce n'est pas une limitation de la langue, mais un problème avec votre code. L'expression Vector{1., 2., 3.}crée un temporaire, mais la normalizefonction renvoie une référence lvalue . Étant donné que l'expression est une lvalue , le compilateur suppose que l'objet sera vivant, mais comme il s'agit d'une référence à un temporaire, l'objet meurt après l'évaluation de l'expression complète, de sorte que vous vous retrouvez avec une référence pendante.

Désormais, si vous modifiez votre conception pour renvoyer un nouvel objet par valeur plutôt qu'une référence à l'objet actuel, il n'y aurait aucun problème et le code fonctionnerait comme prévu.

IMHO, le deuxième exemple est déjà imparfait. Que les opérateurs de modification retournent *thisest pratique de la manière que vous avez mentionnée: cela permet le chaînage des modificateurs. Il peut être utilisé simplement pour transmettre le résultat de la modification, mais cela est sujet aux erreurs car cela peut facilement être négligé. Si je vois quelque chose comme

Vector v{1., 2., 3.};
auto foo = somefunction1(v, 17);
auto bar = somefunction2(true, v, 2, foo);
auto baz = somefunction3(bar.quun(v), 93.2, v.qwarv(foo));

Je ne soupçonnerais pas automatiquement que les fonctions se modifient vcomme un effet secondaire. Bien sûr, ils le pourraient , mais ce serait déroutant. Donc, si je devais écrire quelque chose comme ça, je m'assurerais que cela vreste constant. Pour votre exemple, j'ajouterais des fonctions gratuites

auto normalized(Vector v) -> Vector {return v.normalize();}
auto negated(Vector v) -> Vector {return v.negate();}

puis écrivez les boucles

for( double x : negated(normalized(v)) ) { ... }

et

for( double x : normalized(Vector{1., 2., 3}) ) { ... }

C'est l'OMI mieux lisible, et c'est plus sûr. Bien sûr, cela nécessite une copie supplémentaire, mais pour les données allouées au tas, cela pourrait probablement être fait dans une opération de déplacement C ++ 11 bon marché.