Jak "zwrócić obiekt" w C++?

Po prostu utwórz obiekt i zwróć go

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

Myślę, że zrobisz sobie przysługę, jeśli zapomnisz o optymalizacji i po prostu napiszesz czytelny kod (będziesz musiał później uruchomić profiler - ale nie Pre-optymalizacji).

Po prostu zwróć taki obiekt:

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

Spowoduje to wywołanie konstruktora kopiującego, więc możesz chcieć wykonać własną implementację tego. TAK:

Thing(const Thing& aThing) {}

To może działać trochę wolniej, ale może nie być problemem w ogóle.

Update

Kompilator prawdopodobnie zoptymalizuje wywołanie konstruktora kopiującego, więc nie będzie żadnych dodatkowych kosztów. (Jak zauważył dreamlax w komentarzu).

Czy próbowałeś użyć inteligentnych wskaźników (jeśli coś jest naprawdę dużym i ciężkim obiektem), jak 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 
}

Jednym z szybkich sposobów na określenie, czy Konstruktor kopiujący jest wywoływany, jest dodanie logowania do konstruktora kopiującego twojej klasy:

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

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

Wywołanie someFunction; liczba linii "Copy constructor was called", które otrzymasz, będzie się wahać między 0, 1 i 2. Jeśli nie otrzymasz żadnej, Twój kompilator zoptymalizował wartość zwracaną (co jest dozwolone). Jeśli otrzymasz don ' t get 0, a Twój Konstruktor kopiujący jest śmiesznie drogi, to poszukaj alternatywnych sposobów zwracania instancji z twoje funkcje.

Po pierwsze masz błąd w kodzie, masz na myśli Thing *thing(new Thing()); i tylko return thing;.

• Użyj shared_ptr<Thing>. Niech to będzie wskazówka. Zostanie ona usunięta, gdy ostatnie odniesienie do Thing wyjdzie poza zakres.
• pierwsze rozwiązanie jest bardzo powszechne w naiwnych bibliotekach. Ma pewną wydajność i składniowe koszty, unikaj go, jeśli to możliwe
• użyj drugiego rozwiązania tylko wtedy, gdy możesz zagwarantować, że żadne wyjątki nie zostaną rzucone, lub gdy wydajność jest absolutnie krytyczne (będziesz łączyć się z C lub assembly, zanim to stanie się istotne).

Nie chcę zwracać skopiowanej wartości, ponieważ jest nieefektywna

Na przykład GCC dokonuje tej optymalizacji. W poniższym programie nie są wywoływane ani move constructor, ani copy constructor, ponieważ kopiowanie ani przenoszenie nie jest wykonywane. Zwróć również uwagę na adres c. Nawet jeśli obiekt c jest utworzony wewnątrz funkcji f(), c znajduje się w ramce stosu main().

class C {
public:
    int c = 5;
    C() {}
    C(const C& c) { 
        cout << "Copy constructor " << endl;
    }
    C(const C&& c)  noexcept {
        cout << "Move Constructor" << endl;
    }
};

C f() {
    int beforeC;
    C c;
    int afterC;

    cout << &beforeC << endl;   //0x7ffee02f26ac
    cout << &c << endl;         //0x7ffee02f2710 (notice: even though c is instantiated inside f(), c resides in the stack frame of main()
    cout << &afterC << endl;    //0x7ffee02f26a8

    return c;
}

C g() {
    C c = f(); ///neither copy constructor nor move constructor of C are called, since none is done
    cout << &c << endl;  //0x7ffee02f2710
    return c;
}

int main() {
    int beforeC;
    C c = g();    ///neither copy constructor nor move constructor of C are called, since none is done
    int afterC;

    cout << &beforeC << endl; //0x7ffee02f2718 
    cout << &c << endl;       //0x7ffee02f2710 (notice:even though c is returned from f,it resides in the stack frame of main)
    cout << &afterC << endl;  //0x7ffee02f270c
    return 0;
}

Jestem pewien, że ekspert C++ przyjdzie z lepszą odpowiedzią, ale osobiście podoba mi się drugie podejście. Używanie inteligentnych wskaźników pomaga w problemie zapominania o delete i jak mówisz, wygląda to czystsze niż tworzenie obiektu przed ręką (i nadal konieczność usunięcia go, jeśli chcesz przydzielić go na stercie).