Ungültige Initialisierung der nicht konstante Referenz vom Typ

Question

Im folgenden Code, ich bin nicht in der Lage ein temporäres Objekt als Argument an die printAge Funktion zu übergeben:

struct Person { 
    int age; 
    Person(int _age): age(_age) {} 
}; 

void printAge(Person &person) { 
    cout << "Age: " << person.age << endl; 
} 

int main() { 
    Person p(50); 
    printAge(Person(50)); // fails! 
    printAge(p); 
    return 0; 
} 

Der Fehler, den ich bekommen ist:

error: invalid initialization of non-const reference of type ‘Person&’ from an rvalue of type ‘Person’ 

Ich weiß, dass dies etwas damit zu tun hat, einen lValue an eine Funktion zu übergeben, die einen rValue erwartet ... Gibt es eine Möglichkeit, meinen lValue mit std :: move oder etwas in rValue umzuwandeln? Ich habe versucht, einen konstanten Parameter zu nehmen, aber das scheint nicht zu funktionieren.

Answer 1

Nehmen Sie einfach Ihre Druckfunktion nehmen Sie Ihr Argument von const&. Dies ist auch logisch richtig, da es Ihr Argument nicht ändert.

void printAge(const Person &person) { 
    cout << "Age: " << person.age << endl; 
} 

Das eigentliche Problem ist anders herum. Sie übergeben einen temporären (rvalue) an eine Funktion, die einen lvalue erwartet.

Answer 2

Ihr Code funktioniert nicht, wenn Sie g ++ oder gcc Compiler ausführen. Sie müssen const zu void printAge(const Person &person) hinzufügen. In Visual Studio wird es jedoch einwandfrei funktionieren. Ich habe für VS2010 und VS2012 getestet und in beiden funktioniert der folgende Code gut.

#include<iostream> 

using namespace std; 
struct Person { 
    int age; 
    Person(int _age): age(_age) {} 
}; 

void printAge(Person &person) { 
    cout << "Age: " << person.age << endl; 
} 

int main() { 
    Person p(50); 
    printAge(Person(50)); // DOES NOT fail! 
    printAge(p); 
    return 0; 
} 

Answer 3

Oder, wenn Sie einen C++ 11-kompatible Compiler haben, können verwendet werden, die so universell Referenz Ansatz genannt, die über Referenz kollabiert Regeln für beide L-Wert und rvalue Referenzen binden können:

#include <iostream> 
using namespace std; 

struct Person { 
    int age; 
    Person(int _age): age(_age) {} 
}; 

template<typename T> // can bind to both lvalue AND rvalue references 
void printAge(T&& person) { 
    cout << "Age: " << person.age << endl; 
} 

int main() { 
    Person p(50); 
    printAge(Person(50)); // works now 
    printAge(p); 
    return 0; 
} 

Oder in C++ 14,

void printAge(auto&& person) { 
    cout << "Age: " << person.age << endl; 
}