Bu, döngüler için C ++ 11'in bilinen bir tuzağı mı?

Diyelim ki bazı üye işlevleriyle 3 çiftli tutmak için bir yapımız var:

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

Bu biraz basitlik için yapılıyor, ancak eminim benzer kodların orada olduğunu kabul ediyorsunuz. Yöntemler, uygun şekilde zincirleme yapmanıza izin verir, örneğin:

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

Ya da:

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

Şimdi begin () ve end () fonksiyonlarını sağlasaydık, Vector'ümüzü yeni bir döngü için kullanabiliriz, örneğin x, y ve z 3 koordinatı üzerinden döngü yapmak için (hiç şüphesiz daha "faydalı" örnekler inşa edemezsiniz) Vector öğesini örneğin String ile değiştirerek):

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

Hatta yapabiliriz:

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

ve ayrıca:

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

Ancak, şu (bana öyle geliyor) bozuk:

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

Önceki iki kullanımın mantıksal bir kombinasyonu gibi görünse de, bu son kullanımın sarkan bir referans oluşturduğunu ve önceki ikisi tamamen iyi olduğunu düşünüyorum.

• Bu doğru mu ve geniş ölçüde takdir ediliyor mu?
• Yukarıdakilerin hangi kısmı "kötü" kısımdır, bundan kaçınılması gerekir?
• Dil, aralık tabanlı for döngüsünün tanımını değiştirerek, for-expression içinde oluşturulan geçicilerin döngü süresince var olmasını sağlayarak iyileştirilebilir mi?

Bu doğru mu ve geniş ölçüde takdir ediliyor mu?

Evet, anlayışınız doğru.

Yukarıdakilerin hangi kısmı "kötü" kısımdır, bundan kaçınılması gerekir?

Kötü kısım, bir fonksiyondan geçici olarak döndürülen bir l-değeri referansı almak ve onu bir r-değeri referansına bağlamaktır. Bu kadar kötü:

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

Vector{1., 2., 3.}Derleyicinin kendisine normalizebaşvuran dönüş değerinin ne olduğuna dair hiçbir fikri olmadığı için, geçici süre uzatılamaz .

Dil, aralık tabanlı for döngüsünün tanımını değiştirerek, for-expression içinde oluşturulan geçicilerin döngü süresince var olmasını sağlayarak iyileştirilebilir mi?

Bu, C ++ 'nın çalışma şekliyle oldukça tutarsız olacaktır.

İnsanların geçicilere zincirlenmiş ifadeler veya ifadeler için çeşitli tembel değerlendirme yöntemleri kullanmaları tarafından yapılan bazı kavramaları engeller mi? Evet. Ama aynı zamanda özel durum derleyici kodu gerektirecek ve diğerleriyle neden çalışmadığı konusunda kafa karıştırıcı olacaktır. ifade yapılarıyla .

Çok daha makul bir çözüm, derleyiciye bir işlevin dönüş değerinin her zaman bir referans olduğunu bildirmenin bir yolu olabilir thisve bu nedenle, dönüş değeri geçici olarak genişleyen bir yapıya bağlıysa, o zaman doğru geçiciyi genişletecektir. Bu, dil düzeyinde bir çözüm olsa da.

(Derleyici bunu destekliyorsa) böylece Halen, bunu yapabilir normalize edemez geçici çağrılacak:

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

Bu Vector{1., 2., 3.}.normalize()bir derleme hatası vermesine neden olurken v.normalize()iyi çalışacaktır. Açıkçası, böyle şeyleri düzeltemeyeceksiniz:

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

Ama aynı zamanda yanlış şeyler de yapamazsınız.

Alternatif olarak, yorumlarda önerildiği gibi, rvalue referans sürümünün referans yerine bir değer döndürmesini sağlayabilirsiniz:

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

Taşınacak Vectorgerçek kaynakları olan bir tür olsaydı , Vector ret = std::move(*this);onun yerine kullanabilirdin . Adlandırılmış dönüş değeri optimizasyonu, bunu performans açısından makul ölçüde optimum hale getirir.

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

Bu, dilin bir sınırlaması değil, kodunuzla ilgili bir sorundur. İfade Vector{1., 2., 3.}bir geçici oluşturur, ancak normalizeişlev bir lvalue referansı döndürür . Çünkü ifade bir değerdir , derleyici nesne hayatta olacağını varsayar, ama bu geçici bir referans olduğu için bir sarkan referansla bırakılır böylece, tam ifadeden sonra nesne ölür, değerlendirilir.

Şimdi, tasarımınızı mevcut nesneye bir başvuru yerine değere göre yeni bir nesne döndürecek şekilde değiştirirseniz, herhangi bir sorun olmayacak ve kod beklendiği gibi çalışacaktır.

IMHO, ikinci örnek zaten kusurlu. Değiştirici operatörlerin geri dönmesi *this, bahsettiğiniz şekilde uygundur: değiştiricilerin zincirlenmesine izin verir. Bu olabilir modifikasyon sonucuna basitçe teslim için kullanılan, ancak kolayca göz ardı edilebilir, çünkü bunu hataya eğilimli olması. Gibi bir şey görürsem

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

Fonksiyonların vbir yan etki olarak değiştiğinden otomatik olarak şüphelenmem . Elbette yapabilirlerdi ama kafa karıştırıcı olurdu. Yani böyle bir şey yazacak olsaydım, bunun vsabit kalmasını sağlardım. Örneğiniz için ücretsiz işlevler eklerim

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

ve sonra döngüleri yaz

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

ve

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

Bu, IMO'nun daha iyi okunabilirliği ve daha güvenli. Tabii ki, fazladan bir kopya gerektirir, ancak yığın tahsisli veriler için bu muhtemelen ucuz bir C ++ 11 taşıma işleminde yapılabilir.