rvalore come inizializzatore per costruire un oggetto

Question

Sono nuovo alla programmazione. scusa per il mio cattivo inglese. Ho provato a usare rvalue come inizializzatore per gli oggetti iniziali. Quindi, secondo il codice, stamperebbe quali sono gli operatori di costruzione e assegnazione utilizzati. Ma ho scoperto gli oggetti "what2" e "what3", quelli non stampano nulla. ecco il codice:

#include <iostream> 
using namespace std; 
class X{ 
public: 
    int x; 
    X()= default; 
    X(int num):x{num}{} 
    X(const X& y){ 
     x = y.x; 
     std::cout << "copy constructor" << std::endl; 
     std::cout << x << std::endl; 

    } 
    X& operator=(const X& d){ 
     x = d.x; 
     std::cout << "copy assignment" << std::endl; 
     return *this; 
    } 
    X(X&& y){ 
     x = y.x; 
     std::cout << "move constructor" << std::endl; 
    } 
    X& operator=(X&& b){ 
     x = b.x; 
     std::cout << "move assignment" << std::endl; 
     return *this; 
    } 
}; 

X operator +(const X& a,const X& b){ 
    X tmp{}; 
    tmp.x = a.x +b.x; 
    return tmp; 
} 

int main(int argc, const char * argv[]) { 
    X a{7} , b{11}; 
    X what1; 
    cout << "---------------" << endl; 
    what1 = a+b; 
    cout << "---------------" << endl; 
    X what2{a+b}; 
    cout << "---------------" << endl; 
    X what3 = a+b; 
    cout << "---------------" << endl; 
    std::cout << what1.x << std::endl; 
    std::cout << what2.x << std:: endl; 
    std::cout <<what3.x << std::endl; 
    return 0; 
} 

l'output è:

--------------- 
move assignment 
--------------- 
--------------- 
--------------- 
18 
18 
18 
Program ended with exit code: 0 

solo

"What1" utilizza l'assegnazione in modo corretto. quindi, come posso usare rvalue per iniziare un oggetto? e usando operator = per iniziare un oggetto? grazie mille.

Answer 1

Il tuo codice potrebbe comportare l'utilizzo delle operazioni di spostamento, ma il compilatore ha scelto di effettuare lo spostamento di elide e di restituire operator+ direttamente al sito di chiamata. È possibile vedere questo accadendo se si disabilita la copia elision nel compilatore (-fno-elide-constructors in GCC o Clang).

vostra mossa costruttore e operatore di assegnazione saranno utilizzati con successo in contesti in cui copiare elisione non è consentito, come ad esempio questo:

X what2 { std::move(what1) }; //can't elide copy, move constructor used 

Answer 2

GCC fornisce l'opzione per disabilitare -fno-elide-constructors copia-elisione. se vuoi elidere copy-elision allora usa flag -fno-elide-constructors. Fare riferimento https://stackoverflow.com/questions/12953127/what-are-copy-elision-and-return-value-optimization/27916892#27916892 per maggiori dettagli

Answer 3

Il codice seguente attiva più dei vostri costruttori/operatori, check it out per vedere che innescano in quali casi

#include <iostream> 
using namespace std; 
class X{ 
public: 
    int x; 
    X() 
    { 
     x = 0; 
     std::cout << "constructor" << std::endl; 
    } 
    X(int num):x{num} 
    { 
     std::cout << "list initilizer" << std::endl; 
    } 
    X(const X& y){ 
     x = y.x; 
     std::cout << "copy constructor" << std::endl; 
    } 
    X& operator=(const X& d){ 
     x = d.x; 
     std::cout << "copy assignment" << std::endl; 
     return *this; 
    } 
    X(X&& y){ 
     x = y.x; 
     std::cout << "move constructor" << std::endl; 
    } 
    X& operator=(X&& b){ 
     x = b.x; 
     std::cout << "move assignment" << std::endl; 
     return *this; 
    } 
}; 

X operator +(const X& a,const X& b){ 
    X tmp{}; 
    tmp.x = a.x +b.x; 
    return tmp; 
} 

int main(int argc, const char * argv[]) { 
    X a{7} , b{11}; 
    cout << "---------------" << endl; 
    X what1; 
    cout << "---------------" << endl; 
    what1 = a+b; 
    cout << "---------------" << endl; 
    X what2(a+b); 
    cout << "---------------" << endl; 
    X what3 = X(a); 
    cout << "---------------" << endl; 
    X what4 = X(); 
    cout << "---------------" << endl; 
    X what5 = std::move(what1); 
    cout << "---------------" << endl; 
    what5 = std::move(what1); 
    cout << "---------------" << endl; 
    what5 = what1; 
    cout << "---------------" << endl; 
    return 0; 
}