Chiamare i costruttori in c ++ senza nuovi

Ho visto spesso che le persone creano oggetti in C ++ usando

Thing myThing("asdf");

Invece di questo:

Thing myThing = Thing("asdf");

Questo sembra funzionare (usando gcc), almeno finché non ci sono modelli coinvolti. La mia domanda ora, la prima riga è corretta e in tal caso dovrei usarla?

Entrambe le linee sono in realtà corrette ma fanno cose leggermente diverse.

La prima riga crea un nuovo oggetto nello stack chiamando un costruttore del formato Thing(const char*).

Il secondo è un po 'più complesso. Sostanzialmente fa quanto segue

1. Crea un oggetto di tipo Thingusando il costruttoreThing(const char*)
2. Crea un oggetto di tipo Thingusando il costruttoreThing(const Thing&)
3. Chiamare ~Thing()l'oggetto creato nel passaggio # 1

Presumo con la seconda riga che intendi davvero:

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

quale sarebbe il modo standard di creare nuovi oggetti dinamici (necessari per il legame dinamico e polimorfismo) e memorizzare il loro indirizzo in un puntatore. Il tuo codice fa ciò che JaredPar ha descritto, cioè creando due oggetti (uno ha passato a const char*, l'altro ha passato a const Thing&) e quindi chiamando il distruttore ( ~Thing()) sul primo oggettoconst char* uno).

Al contrario, questo:

Thing thing("uiae");

crea un oggetto statico che viene distrutto automaticamente all'uscita dall'ambito corrente.

Il compilatore potrebbe anche ottimizzare il secondo modulo nel primo modulo, ma non è necessario.

#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;
}

Uscita da 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

Molto semplicemente, entrambe le linee creano l'oggetto sullo stack, anziché sull'heap come fa 'nuovo'. La seconda riga in realtà comporta una seconda chiamata a un costruttore di copie, quindi dovrebbe essere evitata (deve anche essere corretta come indicato nei commenti). Dovresti usare la pila per piccoli oggetti il ​​più possibile poiché è più veloce, tuttavia se i tuoi oggetti sopravvivranno più a lungo della cornice della pila, è chiaramente la scelta sbagliata.

Idealmente, un compilatore dovrebbe ottimizzare il secondo, ma non è necessario. Il primo è il modo migliore. Tuttavia, è piuttosto fondamentale comprendere la distinzione tra stack e heap in C ++, sin da quando è necessario gestire la propria memoria heap.

Ci ho giocato un po 'e la sintassi sembra diventare abbastanza strana quando un costruttore non accetta argomenti. Lasciami fare un esempio:

#include <iostream> 

using namespace std;

class Thing
{
public:
    Thing();
};

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

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

}

quindi basta scrivere Thing myThing senza parentesi in realtà chiama il costruttore, mentre Thing myThing () rende la cosa del compilatore che si desidera creare un puntatore a funzione o qualcosa del genere ?? !!

In aggiunta alla risposta di JaredPar

1 solito ctor, 2a funzione simile a ctor con oggetto temporaneo.

Compila questa fonte da qualche parte qui http://melpon.org/wandbox/ con diversi compilatori

// 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");
}

E vedrai il risultato.

Da ISO / IEC 14882 2003-10-15

8.5, parte 12

La tua prima, seconda costruzione sono chiamate inizializzazione diretta

12.1, parte 13

Una conversione del tipo di notazione funzionale (5.2.3) può essere utilizzata per creare nuovi oggetti del suo tipo. [Nota: la sintassi sembra una chiamata esplicita del costruttore. ] ... Un oggetto creato in questo modo è senza nome. [Nota: 12.2 descrive la durata degli oggetti temporanei. ] [Nota: le chiamate esplicite del costruttore non generano valori, vedere 3.10. ]

Dove leggere su RVO:

12 Funzioni speciali dei membri / 12.8 Copia di oggetti di classe / Parte 15

Quando vengono soddisfatti determinati criteri, un'implementazione può omettere la costruzione della copia di un oggetto di classe, anche se il costruttore della copia e / o il distruttore per l'oggetto hanno effetti collaterali .

Disattivalo con flag di compilazione dal commento per visualizzare tale comportamento di copia)