Esta é uma armadilha conhecida do C ++ 11 para loops?

Vamos imaginar que temos uma estrutura para manter 3 duplos com algumas funções-membro:

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;
  }
  // ...
};

Isso é um pouco artificial para simplificar, mas tenho certeza de que você concorda que código semelhante existe por aí. Os métodos permitem que você encadeie convenientemente, por exemplo:

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

Ou ainda:

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

Agora, se fornecermos as funções begin () e end (), poderíamos usar nosso Vector em um novo estilo de loop for, digamos, para fazer um loop sobre as 3 coordenadas x, y e z (você pode, sem dúvida, construir exemplos mais "úteis" substituindo Vector por, por exemplo, String):

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

Podemos até fazer:

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

e também:

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

No entanto, o seguinte (parece-me) está quebrado:

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

Embora pareça uma combinação lógica dos dois usos anteriores, acho que este último uso cria uma referência pendente, enquanto os dois anteriores são perfeitamente adequados.

• Isso é correto e amplamente apreciado?
• Qual das opções acima é a parte "ruim" que deve ser evitada?
• A linguagem seria melhorada mudando a definição do loop for baseado em intervalo de forma que os temporários construídos na expressão for existissem durante o loop?

Isso é correto e amplamente apreciado?

Sim, seu entendimento das coisas está correto.

Qual das opções acima é a parte "ruim" que deve ser evitada?

A parte ruim é pegar uma referência de valor l para um temporário retornado de uma função e vinculá-la a uma referência de valor r. É tão ruim quanto isso:

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

O Vector{1., 2., 3.}tempo de vida do temporário não pode ser estendido porque o compilador não tem ideia de que o valor de retorno de faz normalizereferência a ele.

A linguagem seria melhorada mudando a definição do loop for baseado em intervalo de forma que os temporários construídos na expressão for existissem durante o loop?

Isso seria altamente inconsistente com o funcionamento do C ++.

Isso impediria certas pegadinhas feitas por pessoas usando expressões encadeadas em temporários ou vários métodos de avaliação preguiçosa para expressões? Sim. Mas também exigiria código do compilador de caso especial, além de ser confuso quanto ao motivo pelo qual não funciona com outras construções de expressão.

Uma solução muito mais razoável seria informar ao compilador que o valor de retorno de uma função é sempre uma referência e this, portanto, se o valor de retorno estiver vinculado a uma construção de extensão temporária, ele estenderá o temporário correto. No entanto, essa é uma solução em nível de linguagem.

Atualmente (se o compilador suportar), você pode fazer com que normalize não ser chamado temporariamente:

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;
};

Isso causará Vector{1., 2., 3.}.normalize()um erro de compilação, enquantov.normalize() funcionará bem. Obviamente, você não será capaz de corrigir coisas como esta:

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

Mas você também não poderá fazer coisas incorretas.

Como alternativa, conforme sugerido nos comentários, você pode fazer com que a versão de referência rvalue retorne um valor em vez de uma referência:

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;
  }
};

Se Vectorfosse um tipo com recursos reais para mover, você poderia usar em seu Vector ret = std::move(*this);lugar. A otimização do valor de retorno nomeado torna isso razoavelmente ideal em termos de desempenho.

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

Isso não é uma limitação da linguagem, mas um problema com seu código. A expressão Vector{1., 2., 3.}cria um temporário, mas a normalizefunção retorna uma referência de lvalue . Porque a expressão é um lvalue , o compilador assume que o objeto estará vivo, mas como é uma referência a um temporário, o objeto morre depois que a expressão completa é avaliada, então você fica com uma referência pendente.

Agora, se você alterar seu design para retornar um novo objeto por valor, em vez de uma referência ao objeto atual, não haverá nenhum problema e o código funcionará conforme o esperado.

IMHO, o segundo exemplo já está falho. O retorno dos operadores modificadores *thisé conveniente da maneira que você mencionou: permite o encadeamento de modificadores. Ele pode ser usado simplesmente para entregar o resultado da modificação, mas fazer isso está sujeito a erros porque pode ser facilmente esquecido. Se eu vir algo como

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));

Eu não suspeitaria automaticamente que as funções se modificam vcomo um efeito colateral. Claro, eles poderiam , mas seria confuso. Então, se eu fosse escrever algo assim, faria com que isso vpermanecesse constante. Para seu exemplo, eu adicionaria funções gratuitas

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

e então escrever os loops

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

e

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

É IMO melhor legível e mais seguro. Obviamente, isso requer uma cópia extra; no entanto, para dados alocados em heap, isso provavelmente poderia ser feito em uma operação de movimentação barata do C ++ 11.