Rückkehr ein lokales Objekt aus einer Funktion

Ist das der richtige Weg ist, um ein Objekt wieder aus einer Funktion?

Car getCar(string model, int year) {
   Car c(model, year);
   return c;
}

void displayCar(Car &car) {
   cout << car.getModel() << ", " << car.getYear() << endl;
}

displayCar(getCar("Honda", 1999));

Ich erhalte eine Fehlermeldung, "taking Adress of temporary". Sollte ich auf diese Weise:

Car &getCar(string model, int year) {
   Car c(model, year);
   return c;
}

InformationsquelleAutor pocoa | 2010-04-02

c++function memory object reference

23

getCar gibt eine Car von Wert, das ist korrekt.

Kann nicht übergeben werden, der Rückgabewert, der ein temporäres Objekt, in displayCar, weil displayCar dauert Car&. Sie können nicht binden, vorübergehend auf einen nicht-const-Referenz. Sollten Sie displayCar zu nehmen, eine const-Referenz:
```
void displayCar(const Car& car) { }
```
Oder, Sie können speichern der temporären in eine lokale variable:
```
Car c = getCar("Honda", 1999);
displayCar(c);
```
Aber, es ist besser displayCar nehmen eine const-Referenz, da es nicht ändern Sie das Objekt.

Nicht Rückgabe eine Referenz auf die lokale Car variable.
- Sie können auch zum speichern von temporären, ohne Berufung auf den copy-Konstruktor (der tritt in Car c = getCar(...) mit einem Verweis auf const: const Car &c = getCar(...), wenn Sie nicht brauchen, um änderungen durch c später auf.
InformationsquelleAutor James McNellis
8

Dein problem ist:
```
void displayCar(Car &car) {
   cout << car.getModel() << ", " << car.getYear() << endl;
}
```
sollten Sie eine const-Referenz:
```
void displayCar( const Car & car ) {
   cout << car.getModel() << ", " << car.getYear() << endl;
}
```
Diese Funktion:
```
Car getCar(string model, int year) {
   Car c(model, year);
   return c;
}
```
ist OK so wie es da steht, aber alle es tut, ist das, was der Konstruktor macht, so ist es redundant. Übergeben Sie einen Wert zurück, anstatt eine Referenz ist, ist die richtige Sache zu tun, für diese Typ Funktion, aber Die Modell-parameter übergeben werden sollen, durch die const Referenz:
```
Car getCar( const string & model, int year) {
```
In der Regel für Klasse Typen wie string oder Auto, die Standardeinstellung für einen parameter sollte immer einen const-Referenz.

InformationsquelleAutor
4

Es ist nicht sicher, um wieder eine lokale variable, die die Referenz aus einer Funktion.

So, ja, das ist richtig:
```
Car getCar(string model, int year) {
   Car c(model, year);
   return c;
}
```
- Hmm, ich brauche so etwas wie eine factory-Funktion, die ein Objekt erstellen und senden Sie es zurück.
- Viele (die meisten?) Compiler optimieren return Car(model, year) so dass keine weitere Kopie gemacht werden muß, so möchte ich loswerden das explizite lokale variable.
- Viele (die meisten?) Compiler implementieren named return value optimization (NRVO) als gut, so gibt es meist keinen Unterschied.
- Sie könnte auch die Verwendung von dynamischem Arbeitsspeicher für all dies durch die Zuweisung einer new Instanz und Rückkehr mit dem Zeiger. Ich würde empfehlen, verwenden Sie die entsprechende Art von smart-pointer, Lecks zu vermeiden.
- Sie mögen Recht haben. Zuletzt habe ich geprüft, benannt Werte waren weniger wahrscheinlich optimiert werden.
- die meisten modernen Compiler auch optimieren entfernt die Kopie-operation in der Funktion als-ist (NRVO), aber ich Stimme zu, dass es ein sicherer baet nur eine temporäre zurückgeben.
- Eigentlich bin ich ja sagen, Sie sollte nicht wieder ein namens temporary. Es pflegte der Fall zu sein, wir könnten zählen auf Compiler durchführen RVO auf Unbenannte Provisorien aber nicht benannte. Laut James, dieser ist veraltet, und jetzt Compiler optimieren wird, es so oder so. Wenn dem so ist, toll.
InformationsquelleAutor Brian R. Bondy
2

Ja, es ist definitiv nicht sicher für die Rückgabe einer Referenz oder einen Zeiger auf ein temporäres Objekt. Wenn es abgelaufen ist (dh, wenn die Funktion getCar beendet), werden Sie Links mit zu, was technisch bekannt als "dangling pointer".

Allerdings, wenn Sie daran interessiert sind, auf die Verringerung der Kopier-Operationen auf ein Objekt, sollten Sie sich C++0x ' s "Move-Semantik". Es ist ein relativ neues Konzept, aber ich bin sicher, es wird sich main-stream schnell genug. GCC-4.4 aufwärts unterstützt C++0x (verwenden Sie die compiler-option -std=c++0x zu aktivieren).

InformationsquelleAutor themoondothshine
0

Sogar noch besser:
```
Car getCar(string model, int year) { 
      return Car(model, year);  
}
```
- Genau das meinte ich mit "kopieren" in meiner Antwort. Obwohl gerade dies ist die standard-Lösung, es ist viel mehr eine teure operation als Rückgabe nur eine Adresse.
- Die meisten Compiler (alle die ich kenne) führen RVO hier, so ist es ein wirklich günstigen Betrieb.
InformationsquelleAutor Nemanja Trifunovic

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.