copiar construtor por endereço

Question

Eu tenho dois construtores de cópia

Foo(Foo &obj){

}
Foo(Foo *obj){

}

Quando o construtor da segunda cópia será chamado?

Answer 1

Deixando de lado que o segundo construtor não é um construtor de cópia - você realmente queria saber quando o segundo construtor será chamado.

O Foo(Foo* obj); construtor é um construtor de parâmetro único - porque não foi marcado com o explicit palavra-chave, ela fornece uma conversão implícita de Foo* para Foo.Pode ser chamado a qualquer momento quando um Foo* é usado no lugar de um Foo ou const Foo& - se estiver sendo chamado inesperadamente, é quase certo que é isso que está acontecendo.

Em geral, os construtores de parâmetro único devem ser construtores de cópia (que outras respostas explicaram) ou devem ser marcados explicit.Construtores que fornecem conversões implícitas devem ser usados ​​com moderação.

Answer 2

Não, você não - você tem um construtor de cópia

Foo( Foo * obj );

não é um construtor de cópia e nunca será usado como tal pelo compilador C ++. É claro que você pode usá -lo:

Foo a;
Foo b( & a );   // use your constructor

Observe também que seu construtor de cópia real deve ser declarado como;

Foo( const Foo & f );

Embora a falta de const não impeça que seja um construtor de cópias.

Answer 3

O segundo não é um construtor de cópia. É um construtor que é chamado quando você cria um novo objeto Foo, dando um ponteiro a um fao como parâmetro.

Foo foo0;
Foo foo1 = foo0;  // Calls copy constructor
Foo foo2(foo0);   // Calls copy constructor
Foo foo3(&foo0);  // Calls constructor taking a pointer as parameter

Answer 4

Um de seus construtores é um construtor de cópias, o outro é apenas um construtor normal.

O segundo será chamado se você inicializar explicitamente um Foo de um ponteiro para Foo ou em outras situações em que uma conversão de um ponteiro para Foo para um valor R. Foo é necessário, como a passagem de argumentos e os retornos da função.

Geralmente é uma má idéia ter uma conversão tão implícita; Pode ocorrer quando você não espera e pode transformar erros de digitação de erros de compilação em comportamento incomum em tempo de execução.