Come "restituire un oggetto" in C ++?

So che il titolo sembra familiare dato che ci sono molte domande simili, ma sto chiedendo un aspetto diverso del problema (conosco la differenza tra avere le cose in pila e metterle in pila).

In Java posso sempre restituire riferimenti ad oggetti "locali"

public Thing calculateThing() {
    Thing thing = new Thing();
    // do calculations and modify thing
    return thing;
}

In C ++, per fare qualcosa di simile ho 2 opzioni

(1) Posso usare i riferimenti ogni volta che devo "restituire" un oggetto

void calculateThing(Thing& thing) {
    // do calculations and modify thing
}

Quindi usalo in questo modo

Thing thing;
calculateThing(thing);

(2) Oppure posso restituire un puntatore a un oggetto allocato dinamicamente

Thing* calculateThing() {
    Thing* thing(new Thing());
    // do calculations and modify thing
    return thing;
}

Quindi usalo in questo modo

Thing* thing = calculateThing();
delete thing;

Usando il primo approccio non dovrò liberare memoria manualmente, ma per me rende difficile leggere il codice. Il problema con il secondo approccio è che dovrò ricordarmene delete thing;, il che non sembra abbastanza carino. Non voglio restituire un valore copiato perché è inefficiente (credo), quindi ecco le domande

• Esiste una terza soluzione (che non richiede la copia del valore)?
• C'è qualche problema se mi attengo alla prima soluzione?
• Quando e perché dovrei usare la seconda soluzione?

Non voglio restituire un valore copiato perché è inefficiente

Provalo.

Cerca RVO e NRVO e in C ++ 0x move-semantics. Nella maggior parte dei casi in C ++ 03, un parametro out è solo un buon modo per rendere il tuo codice brutto, e in C ++ 0x ti faresti davvero del male usando un parametro out.

Basta scrivere codice pulito, restituire per valore. Se le prestazioni sono un problema, descrivile (smetti di indovinare) e trova cosa puoi fare per risolverle. Probabilmente non restituirà le cose dalle funzioni.

Detto questo, se sei pronto a scrivere in quel modo, probabilmente vorrai fare il parametro out. Evita l'allocazione dinamica della memoria, che è più sicura e generalmente più veloce. Richiede che tu abbia un modo per costruire l'oggetto prima di chiamare la funzione, il che non ha sempre senso per tutti gli oggetti.

Se si desidera utilizzare l'allocazione dinamica, il minimo che si può fare è inserirlo in un puntatore intelligente. (Questo dovrebbe essere fatto sempre in ogni caso) Quindi non ti preoccupare di eliminare nulla, le cose sono eccezionalmente sicure, ecc. L'unico problema è che probabilmente è più lento del ritorno in base al valore comunque!

Basta creare l'oggetto e restituirlo

Thing calculateThing() {
    Thing thing;
    // do calculations and modify thing
     return thing;
}

Penso che ti farai un favore se dimentichi l'ottimizzazione e scrivi solo codice leggibile (dovrai eseguire un profiler in seguito, ma non pre-ottimizzare).

Restituisci un oggetto come questo:

Thing calculateThing() 
{
   Thing thing();
   // do calculations and modify thing
   return thing;
}

Questo invocherà il costruttore di copie su Things, quindi potresti voler fare la tua implementazione. Come questo:

Thing(const Thing& aThing) {}

Questo potrebbe comportare un po 'più lento, ma potrebbe non essere affatto un problema.

Aggiornare

Il compilatore probabilmente ottimizzerà la chiamata al costruttore della copia, quindi non ci saranno costi aggiuntivi. (Come ha sottolineato dreamlax nel commento).

Hai provato a usare i puntatori intelligenti (se Thing è davvero un oggetto grande e pesante), come auto_ptr:

std::auto_ptr<Thing> calculateThing()
{
  std::auto_ptr<Thing> thing(new Thing);
  // .. some calculations
  return thing;
}


// ...
{
  std::auto_ptr<Thing> thing = calculateThing();
  // working with thing

  // auto_ptr frees thing 
}

Un modo rapido per determinare se viene chiamato un costruttore di copie è aggiungere la registrazione al costruttore di copie della classe:

MyClass::MyClass(const MyClass &other)
{
    std::cout << "Copy constructor was called" << std::endl;
}

MyClass someFunction()
{
    MyClass dummy;
    return dummy;
}

Chiama someFunction; il numero di righe "Copia costruttore è stato chiamato" che otterrai varierà tra 0, 1 e 2. Se non ne ottieni, il tuo compilatore ha ottimizzato il valore restituito (cosa che è permesso fare). Se ottieni non ottieni 0 e il tuo costruttore di copie è ridicolmente costoso, quindi cerca modi alternativi per restituire istanze dalle tue funzioni.

Innanzitutto hai un errore nel codice, intendi avere Thing *thing(new Thing());e solo return thing;.

• Usa shared_ptr<Thing>. Deref come se fosse un puntatore. Verrà eliminato per te quando l'ultimo riferimento al Thingcontenuto non rientra nell'ambito.
• La prima soluzione è molto comune nelle librerie ingenue. Ha delle prestazioni e un sovraccarico sintattico, evitalo se possibile
• Utilizzare la seconda soluzione solo se è possibile garantire che non vengano generate eccezioni o quando le prestazioni sono assolutamente critiche (l'interfacciamento con C o l'assemblaggio prima ancora che diventi rilevante).

Sono sicuro che un esperto di C ++ troverà una risposta migliore, ma personalmente mi piace il secondo approccio. L'uso dei puntatori intelligenti aiuta a risolvere il problema dell'oblio deletee come dici, sembra più pulito che dover creare un oggetto prima mano (e comunque doverlo eliminare se vuoi allocarlo sull'heap).