Fehler bei der Verwendung eines verschobenen Werts

Question

Nachdem ich den Wechsel zu C++ 11 vorgenommen habe, übertrage ich nun systematisch meine Strings nach Wert in meinen Konstruktoren. Aber jetzt merke ich, dass es macht es leichter Fehler einzuführen, wenn auch der Wert im Körper des Konstruktor:

class A(std::string val): 
    _val(std::move(val)) 
{ 
    std::cout << val << std::endl; // Bug!!! 
} 

Was kann ich die Chancen zu reduzieren, tun es falsch zu bekommen?

Answer 1

Name Argumente, dessen Zweck es ist, in einem gewissen unverwechselbaren Art und Weise eingefahrene von werden, zumindest im Rahmen der Umsetzung des Konstrukteurs

A::A(std::string val_moved_from): 
_val(std::move(val_moved_from)) 
{ 
    std::cout << val_moved_from << std::endl; // Bug, but obvious 
} 

dann von ihnen so früh wie möglich bewegen (in der Konstruktionsliste, sagt) .

Wenn Sie solch eine lange Konstruktionsliste haben, können Sie zwei Verwendungen von val_moved_from darin vermissen, das hilft nicht.

Eine Alternative wäre, einen Vorschlag zu schreiben, um dieses Problem zu beheben. Nehmen wir an, Sie erweitern C++ so, dass die Typen oder Bereiche lokaler Variablen durch Operationen an ihnen geändert werden können. Daher verschiebt sich std::safe_move(X) von X und markiert X als abgelaufene Variable, die für den Rest des Gültigkeitsbereichs nicht mehr gültig ist. Herauszufinden, was zu tun ist, wenn eine Variable halb abgelaufen ist (abgelaufen in einem Zweig, aber nicht in einem anderen Zweig), ist eine interessante Frage.

Weil das verrückt ist, können wir es stattdessen als ein Bibliotheksproblem angreifen. Bis zu einem gewissen Grad können wir diese Art von Tricks (eine Variable, deren Typ sich ändert) zur Laufzeit fälschen. Das ist grob, aber gibt die Idee:

template<typename T> 
struct read_once : std::tr2::optional<T> { 
    template<typename U, typename=typename std::enable_if<std::is_convertible<U&&, T>::value>::type> 
    read_once(U&& u):std::tr2::optional<T>(std::forward<U>(u)) {} 
    T move() && { 
    Assert(*this); 
    T retval = std::move(**this); 
    *this = std::tr2::none_t; 
    return retval; 
    } 
    // block operator*? 
}; 

dh schreiben einen linearen Typ, der nur von über move gelesen werden kann, und nach dieser Zeit mit dem Lesen Assert s oder wirft.

ändern Sie dann Ihren Konstruktor:

A::A(read_once<std::string> val): 
    _val(val.move()) 
{ 
    std::cout << val << std::endl; // does not compile 
    std::cout << val.move() << std::endl; // compiles, but asserts or throws 
} 

mit Speditions Konstrukteurs können Sie eine weniger lächerlich Schnittstelle ohne read_once Arten aussetzen, dann uns auf Ihre Konstrukteure auf Ihre „sicher“ (möglicherweise private) Versionen mit read_once<> Wrapper um die Argumente.

Wenn Ihre Tests alle Codepfade decken, werden Sie Assert s statt nur leer std::string ist schön, auch wenn Sie gehen und move mehr als einmal von Ihrem read_once Variablen.

Answer 2

"Nachdem ich den Wechsel zu C++ 11 gemacht habe, übertrage ich jetzt systematisch meine Strings nach Wert in meinen Konstruktoren."

Es tut mir leid, ich sehe nicht, warum man das tun möchte. Welche Verbesserung bietet dies in Bezug auf die traditionelle Methode? (Das ist im Grunde Bug-Beweis).

 
class A(const std::string & s): 
    _val(s) 
{ 
    std::cout << s << std::endl; // no Bug!!! 
    std::cout << _val << std::endl; // no Bug either !!! 
}