Wywołanie konstruktorów w C ++ bez nowego

Często widziałem, że ludzie tworzą obiekty w C ++ używając

Thing myThing("asdf");

Zamiast tego:

Thing myThing = Thing("asdf");

Wydaje się, że to działa (używając gcc), przynajmniej tak długo, jak długo nie ma żadnych szablonów. Moje pytanie, czy pierwsza linia jest poprawna, a jeśli tak, to powinienem jej użyć?

Obie wersety są w rzeczywistości poprawne, ale robią nieco inne rzeczy.

Pierwsza linia tworzy nowy obiekt na stosie przez wywołanie konstruktora formatu Thing(const char*).

Drugi jest nieco bardziej złożony. Zasadniczo wykonuje następujące czynności

1. Utwórz obiekt typu Thingprzy użyciu konstruktoraThing(const char*)
2. Utwórz obiekt typu Thingprzy użyciu konstruktoraThing(const Thing&)
3. Wywołaj ~Thing()obiekt utworzony w kroku 1

Zakładam, że drugą linią masz na myśli:

Thing *thing = new Thing("uiae");

który byłby standardowym sposobem tworzenia nowych obiektów dynamicznych (niezbędnych do dynamicznego wiązania i polimorfizmu) i przechowywania ich adresu we wskaźniku. Twój kod robi to, co opisał JaredPar, mianowicie tworzy dwa obiekty (jeden przeszedł a const char*, drugi przeszedł a const Thing&), a następnie wywołuje destruktor ( ~Thing()) na pierwszym obiekcie (tym const char*jednym).

Z kolei to:

Thing thing("uiae");

tworzy obiekt statyczny, który jest automatycznie niszczony po wyjściu z bieżącego zakresu.

Kompilator może dobrze zoptymalizować drugi formularz do pierwszego formularza, ale nie musi.

#include <iostream>

class A
{
    public:
        A() { std::cerr << "Empty constructor" << std::endl; }
        A(const A&) { std::cerr << "Copy constructor" << std::endl; }
        A(const char* str) { std::cerr << "char constructor: " << str << std::endl; }
        ~A() { std::cerr << "destructor" << std::endl; }
};

void direct()
{
    std::cerr << std::endl << "TEST: " << __FUNCTION__ << std::endl;
    A a(__FUNCTION__);
    static_cast<void>(a); // avoid warnings about unused variables
}

void assignment()
{
    std::cerr << std::endl << "TEST: " << __FUNCTION__ << std::endl;
    A a = A(__FUNCTION__);
    static_cast<void>(a); // avoid warnings about unused variables
}

void prove_copy_constructor_is_called()
{
    std::cerr << std::endl << "TEST: " << __FUNCTION__ << std::endl;
    A a(__FUNCTION__);
    A b = a;
    static_cast<void>(b); // avoid warnings about unused variables
}

int main()
{
    direct();
    assignment();
    prove_copy_constructor_is_called();
    return 0;
}

Wyjście z gcc 4.4:

TEST: direct
char constructor: direct
destructor

TEST: assignment
char constructor: assignment
destructor

TEST: prove_copy_constructor_is_called
char constructor: prove_copy_constructor_is_called
Copy constructor
destructor
destructor

Po prostu obie linie tworzą obiekt na stosie, a nie na stercie, jak robi to „nowy”. Druga linia faktycznie zawiera drugie wywołanie konstruktora kopiującego, więc należy tego unikać (należy to również poprawić, jak wskazano w komentarzach). Powinieneś używać stosu do małych obiektów tak często, jak to możliwe, ponieważ jest szybszy, jednak jeśli twoje obiekty mają przetrwać dłużej niż ramka stosu, jest to zdecydowanie zły wybór.

Idealnie byłoby, gdyby kompilator zoptymalizował drugą, ale nie jest to wymagane. Pierwszy to najlepszy sposób. Jednak bardzo ważne jest zrozumienie różnicy między stosem a stertą w C ++, bez względu na to, że musisz zarządzać własną pamięcią stosu.

Trochę się tym bawiłem i składnia wydaje się być dość dziwna, gdy konstruktor nie przyjmuje argumentów. Podam przykład:

#include <iostream> 

using namespace std;

class Thing
{
public:
    Thing();
};

Thing::Thing()
{
    cout << "Hi" << endl;
}

int main()
{
    //Thing myThing(); // Does not work
    Thing myThing; // Works

}

więc samo napisanie Thing myThing bez nawiasów faktycznie wywołuje konstruktor, podczas gdy Thing myThing () sprawia, że ​​kompilator, który chcesz utworzyć, jest wskaźnikiem funkcji lub czymś podobnym ?? !!

W uzupełnieniu do odpowiedzi JaredPar

1-zwykły ctor, 2-funkcyjny-podobny-ctor z tymczasowym obiektem.

Skompiluj to źródło gdzieś tutaj http://melpon.org/wandbox/ z różnymi kompilatorami

// turn off rvo for clang, gcc with '-fno-elide-constructors'

#include <stdio.h>
class Thing {
public:
    Thing(const char*){puts(__FUNCTION__ );}
    Thing(const Thing&){puts(__FUNCTION__ );}   
    ~Thing(){puts(__FUNCTION__);}
};
int main(int /*argc*/, const char** /*argv*/) {
    Thing myThing = Thing("asdf");
}

I zobaczysz wynik.

Z ISO / IEC 14882 2003-10-15

8.5, część 12

Twoja pierwsza i druga konstrukcja to inicjalizacja bezpośrednia

12.1, część 13

Funkcjonalna konwersja typu notacji (5.2.3) może być użyta do tworzenia nowych obiektów tego typu. [Uwaga: składnia wygląda jak jawne wywołanie konstruktora. ] ... Utworzony w ten sposób obiekt nie ma nazwy. [Uwaga: 12.2 opisuje czas życia obiektów tymczasowych. ] [Uwaga: jawne wywołania konstruktora nie dają lvalues, patrz 3.10. ]

Gdzie poczytać o RVO:

12 Specjalne funkcje składowe / 12.8 Kopiowanie obiektów klas / Część 15

Gdy spełnione są określone kryteria, implementacja może pominąć tworzenie kopii obiektu klasy, nawet jeśli konstruktor kopiujący i / lub destruktor obiektu mają efekty uboczne .

Wyłącz to flagą kompilatora z komentarza, aby zobaczyć takie zachowanie kopiowania)