[C++] Verschiebekonstruktor

[Markus (Gast)]

Hallo,

ich dachte, das Thema Konstruktoren verstanden zu haben, aber dem ist 
wohl nicht so...
Gegeben ist folgender Quellcode, wobei die Konstruktoren in der Form 
auch ohne explizites Hinschreiben vom Compiler automatisch hinzugefügt 
würden:

#include<string>
#include<memory>
#include <iostream>

using namespace std;

class SimplerName {

public:
    void setName(const std::string& s) {
        m_name = s;
    }

    std::string getName() const{
        return m_name;
    }
// Standardkonstruktor
    SimplerName()
        : m_name() {}

// Kopierkonstruktor
    SimplerName(const SimplerName& n)
        : m_name{ n.m_name } { }

// Verschiebekonstruktor
   SimplerName(SimplerName&& n)
        : m_name{ static_cast<std::string&&>(n.m_name) } {}
        // es ginge auch : m_name{ std::move(n.m_name) } { }

// Kopier-Zuweisungsoperator
    SimplerName& operator=(const SimplerName& n) {
        m_name = n.m_name;
        return *this;
    }
// Verschiebe-Zuweisungsoperator
    SimplerName& operator=(SimplerName&& n) {
        m_name = static_cast<std::string&&>(n.m_name);
        return *this;
    }
// Destruktor
    ~SimplerName() {}

private:
    std::string m_name;
};



int main() {
    SimplerName n1;             // Standardkonstruktor
    n1.setName("Peter");
    SimplerName n2(n1);         // Kopierkonstruktor
    SimplerName n3;
    n3 = n2;                    // Kopier-Zuweisungsoperator
    cout << n1.getName() << endl;
    cout << n2.getName() << endl;
    cout << n3.getName() << endl;
    cout << "---------" << endl;

    n2 = move(SimplerName());   // Verschiebe-Zuweisungsoperator
    SimplerName n4(move(SimplerName()));    // Move-Konstruktor
    cout << n2.getName() << endl;
    cout << n4.getName() << endl;
}

Das ganze läuft erstmal durch. 'n2' und 'n4' besitzen keinen Namen bzw. 
das Attribut 'm_name' ist leer, da in den zugehörigen Anweisungen in den 
letzten Zeilen nichts angegeben wird.

Warum aber funktionieren die folgenden Zeilen nicht?
Ich dachte, das wäre genau der Trick an der Sache, daß temporäre 
namenlose Objekte wie "Schmidt" übergeben werden können?

n2 = move(SimplerName{ "Schmidt" });            // error: no matching function for call to 'SimplerName::SimplerName(<brace-enclosed initializer list>)'|
n2 = move(SimplerName( "Schmidt" ));        // error: no matching function for call to 'SimplerName::SimplerName(const char [8])'|

n2 = SimplerName{ "Schmidt" };            // error: no matching function for call to 'SimplerName::SimplerName(<brace-enclosed initializer list>)'|
n2 = SimplerName( "Schmidt" );        // error: no matching function for call to 'SimplerName::SimplerName(const char [8])'|//

SimplerName n5(move(SimplerName{ "Meier" }));
SimplerName n5(move(SimplerName( "Meier" )));

SimplerName n5(SimplerName{ "Meier" });
SimplerName n5(SimplerName( "Meier" ));

SimplerName n5{SimplerName{ "Meier" }};

In einem Beispiel vorher hat der Autor eine Klasse 'Name' implementiert, 
da funktioniert das alles. Allerdings wird hier auf das 'move' 
verzichtet, der Aufruf lautet einfach:

Name n7{ Name{ "Muller" } };

Wo ist hier der Unterschied bzw. was muß ich in 'SimplerName' ändern, um 
einen Namen übergeben zu können?

In der Klasse 'Name' sind die Konstruktoren selbst geschrieben. Ändere 
ich den Verschiebekonstruktor in 'SimplerName' entsprechend ab, 
funktioniert das jedoch nicht:

    SimplerName(SimplerName&& n) {
        m_name = n.m_name;
        n.m_name = nullptr;
    }

 Wieso nicht?

[Oliver S. (oliverso)]

Markus schrieb:
> // error: no matching function for call to
> 'SimplerName::SimplerName(<brace-enclosed initializer list>)'|

Genau lesen, was da steht. Das Problem ist nicht das move.

Oliver

[Niklas G. (erlkoenig)]

Du hast überhaupt keinen Konstruktor welcher einen String-Parameter hat, 
wie soll SimplerName{ "Meier" } dann funktionieren?

Und warum eigentlich static_cast<std::string&&> statt std::move ?

Hier:

    std::string getName() const{
        return m_name;
    }

Legst du jedes Mal eine Kopie an.

    const std::string& getName() const{
        return m_name;
    }

wäre effizienter. Der Aufrufer kann falls nötig immer noch eine Kopie 
anlegen.

[Markus (Gast)]

Niklas G. schrieb:
> Du hast überhaupt keinen Konstruktor welcher einen String-Parameter hat,
> wie soll SimplerName{ "Meier" } dann funktionieren?

Ah, wenn ich den Standardkonstruktor ändere zu

    SimplerName(std::string s = "Oskar") {
        m_name = s;
    }

erfolgt bei Aufruf von bspw.

SimplerName n5(move(SimplerName{ "Meier" }));

 eine explizite Typumwandlung (?). Jedenfalls funktionieren mit diesem 
Standardkonstruktor die oben genannten Aufrufe von n2 und n5, und zwar 
allesamt, egal ob mit oder ohne 'move'. Wozu ist das dann gut?


> Und warum eigentlich static_cast<<std::string&&>> statt std::move ?
Im Buch heißt es dazu:
(Zitat Anfang)
Der vom Compiler zu unserer Klasse hinzugefügte Verschiebekonstruktor 
sieht folgendermaßen aus:

SimplerName(SimplerName&& n)
        : m_name{ static_cast<std::string&&>(n.m_name) } {}

Der 'static cast' ist notwendig, um aus der lvalue-Referenz n.m_name 
eine rvalue-Referenz zu machen, damit für das Attribut ebenfalls der 
Verschiebekonstruktor aufgerufen wird. Hätten wir den Konstruktor selbst 
programmiert, wäre auch der Einsatz von 'move' möglich gewesen:

SimplerName(SimplerName&& n)
        : m_name{ std::move(n.m_name) } { }

(Zitat Ende)

[Niklas G. (erlkoenig)]

Markus schrieb:
> , egal ob mit oder ohne 'move'. Wozu ist das dann gut?

Zu nichts. Der Ausdruck 'SimplerName{ "Schmidt" }' ist bereits ein 
rvalue. Da noch ein move() drum zu packen bringt nichts.

Markus schrieb:
> Ah, wenn ich den Standardkonstruktor ändere zu

Besser wäre:

SimplerName(std::string s = "Oskar") : m_name (std::move (s))
{}

Dann noch zusätzlich, um explizit eine Kopie anzufordern:

SimplerName(const std::string& s) : m_name (s)
{}

Vermeidet den Zwischenschritt.

Markus schrieb:
> Hätten wir den Konstruktor selbst programmiert, wäre auch der Einsatz
> von 'move' möglich gewesen:

Ja, und move ist lesbarer und kürzer, würde ich daher dem manuellen 
static_cast vorziehen.