Llamar a constructores en c ++ sin novedades

A menudo he visto que las personas crean objetos en C ++ usando

Thing myThing("asdf");

En lugar de esto:

Thing myThing = Thing("asdf");

Esto parece funcionar (usando gcc), al menos mientras no haya plantillas involucradas. Mi pregunta ahora, ¿es correcta la primera línea y si es así debo usarla?

Ambas líneas son correctas, pero hacen cosas sutilmente diferentes.

La primera línea crea un nuevo objeto en la pila llamando a un constructor del formato Thing(const char*).

El segundo es un poco más complejo. Esencialmente hace lo siguiente

1. Crear un objeto de tipo Thingusando el constructorThing(const char*)
2. Crear un objeto de tipo Thingusando el constructorThing(const Thing&)
3. Llame ~Thing()al objeto creado en el paso 1

Supongo que con la segunda línea realmente quieres decir:

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

cuál sería la forma estándar de crear nuevos objetos dinámicos (necesarios para el enlace dinámico y el polimorfismo) y almacenar su dirección en un puntero. Su código hace lo que JaredPar describió, es decir, crear dos objetos (uno pasó a const char*, el otro pasó a const Thing&), y luego llamar al destructor ( ~Thing()) en el primer objeto (el const char*uno).

Por el contrario, esto:

Thing thing("uiae");

crea un objeto estático que se destruye automáticamente al salir del alcance actual.

El compilador puede optimizar la segunda forma en la primera forma, pero no tiene que hacerlo.

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

Salida de 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

En pocas palabras, ambas líneas crean el objeto en la pila, en lugar de en el montón como lo hace 'nuevo'. La segunda línea en realidad implica una segunda llamada a un constructor de copias, por lo que debe evitarse (también debe corregirse como se indica en los comentarios). Debe usar la pila para objetos pequeños tanto como sea posible, ya que es más rápido, sin embargo, si sus objetos van a sobrevivir por más tiempo que el marco de la pila, entonces es claramente la elección incorrecta.

Idealmente, un compilador optimizaría el segundo, pero no es obligatorio. La primera es la mejor manera. Sin embargo, es bastante crítico comprender la distinción entre pila y montón en C ++, ya que debe administrar su propia memoria de montón.

Jugué un poco con él y la sintaxis parece ser bastante extraña cuando un constructor no toma argumentos. Déjame dar un ejemplo:

#include <iostream> 

using namespace std;

class Thing
{
public:
    Thing();
};

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

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

}

¡así que escribir Thing myThing sin corchetes en realidad llama al constructor, mientras que Thing myThing () hace que el compilador desee crear un puntero de función o algo así!

En anexar a JaredPar respuesta

1-habitual ctor, 2-función-como-ctor con objeto temporal.

Compile esta fuente en algún lugar aquí http://melpon.org/wandbox/ con diferentes compiladores

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

Y verás el resultado.

De ISO / IEC 14882 2003-10-15

8.5, parte 12

Su primera y segunda construcción se llaman inicialización directa

12.1, parte 13

Se puede usar una conversión de tipo de notación funcional (5.2.3) para crear nuevos objetos de su tipo. [Nota: La sintaxis parece una llamada explícita del constructor. ] ... Un objeto creado de esta manera no tiene nombre. [Nota: 12.2 describe la vida útil de los objetos temporales. ] [Nota: las llamadas explícitas de constructor no producen valores de l, ver 3.10. ]

Dónde leer sobre RVO:

12 Funciones especiales para miembros / 12.8 Copia de objetos de clase / Parte 15

Cuando se cumplen ciertos criterios, se permite que una implementación omita la construcción de copia de un objeto de clase, incluso si el constructor y / o destructor de copia para el objeto tiene efectos secundarios .

Desactívelo con el indicador del compilador del comentario para ver dicho comportamiento de copia)