Chamando construtores em c ++ sem novas

Eu sempre vi que as pessoas criam objetos em C ++ usando

Thing myThing("asdf");

Em vez disso:

Thing myThing = Thing("asdf");

Isso parece funcionar (usando o gcc), pelo menos enquanto não houver modelos envolvidos. Minha pergunta agora, a primeira linha está correta e, em caso afirmativo, devo usá-la?

As duas linhas estão de fato corretas, mas fazem coisas sutilmente diferentes.

A primeira linha cria um novo objeto na pilha chamando um construtor do formato Thing(const char*).

O segundo é um pouco mais complexo. Essencialmente, faz o seguinte

1. Crie um objeto do tipo Thingusando o construtorThing(const char*)
2. Crie um objeto do tipo Thingusando o construtorThing(const Thing&)
3. Chame ~Thing()o objeto criado na etapa # 1

Suponho que com a segunda linha você realmente queira dizer:

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

que seria a maneira padrão de criar novos objetos dinâmicos (necessários para ligação dinâmica e polimorfismo) e armazenar seu endereço em um ponteiro. Seu código faz o que JaredPar descreveu, ou seja, criar dois objetos (um passou a const char*, o outro passou a const Thing&) e, em seguida, chamar o destruidor ( ~Thing()) no primeiro objeto (oconst char* aquele).

Por outro lado, isso:

Thing thing("uiae");

cria um objeto estático que é destruído automaticamente ao sair do escopo atual.

O compilador pode otimizar o segundo formulário para o primeiro, mas não precisa.

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

Saída do 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

Simplesmente, ambas as linhas criam o objeto na pilha, em vez de no heap como 'new'. A segunda linha, na verdade, envolve uma segunda chamada para um construtor de cópias, portanto deve ser evitada (também precisa ser corrigida conforme indicado nos comentários). Você deve usar a pilha para objetos pequenos o máximo possível, pois é mais rápida; no entanto, se seus objetos sobreviverem por mais tempo que o quadro da pilha, é claramente a escolha errada.

Idealmente, um compilador otimizaria o segundo, mas não é necessário. O primeiro é o melhor caminho. No entanto, é bastante crítico entender a distinção entre pilha e pilha no C ++, pois você deve gerenciar sua própria memória de pilha.

Eu brinquei um pouco com isso e a sintaxe parece bastante estranha quando um construtor não aceita argumentos. Deixe-me dar um exemplo:

#include <iostream> 

using namespace std;

class Thing
{
public:
    Thing();
};

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

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

}

então apenas escrever Thing myThing sem colchetes realmente chama o construtor, enquanto Thing myThing () faz com que o compilador deseje criar um ponteiro de função ou algo assim ?? !!

Em anexo a JaredPar resposta

1-Ctor usual, 2-Função-como-Ctor com objeto temporário.

Compile esta fonte em algum lugar aqui http://melpon.org/wandbox/ com 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");
}

E você verá o resultado.

ISO / IEC 14882 2003-10-15

8.5, parte 12

Sua primeira e segunda construção são chamadas de inicialização direta

12.1, parte 13

Uma conversão de tipo de notação funcional (5.2.3) pode ser usada para criar novos objetos desse tipo. [Nota: A sintaxe se parece com uma chamada explícita do construtor. ] ... Um objeto criado dessa maneira não tem nome. [Nota: 12.2 descreve a vida útil dos objetos temporários. ] [Nota: chamadas explícitas ao construtor não produzem valores l, consulte 3.10. ]

Onde ler sobre o RVO:

12 Funções de membro especiais / 12.8 Copiando objetos de classe / Parte 15

Quando certos critérios são atendidos, uma implementação pode omitir a construção de cópia de um objeto de classe, mesmo se o construtor e / ou destruidor de cópia do objeto tiver efeitos colaterais .

Desative-o com o sinalizador do compilador do comentário para visualizar esse comportamento de cópia)