enclosed - Sintaxis de inicialización de instancias C++

initialize vector c++ 11

Question

Dada una clase como esta:

class Foo {
public:
Foo(int);
Foo(const Foo&);
Foo& operator=(int);
private:
// ...
};

¿Son estas dos líneas exactamente equivalentes, o hay una sutil diferencia entre ellas?

Foo f(42);
Foo f = 42;

Editar: confundí las cosas haciendo que el constructor de Foo fuera "explícito" en la pregunta original. Lo eliminé, pero aprecio las respuestas.

También agregué la declaración de un constructor de copia, para dejar en claro que la copia puede no ser una operación trivial.

Lo que realmente quiero saber es, según el estándar C ++, "Foo f = 42" llamará directamente al constructor Foo (int), o se llamará al constructor de copia?

Parece que fasih.ahmed tiene la respuesta que estaba buscando (a menos que esté equivocado).

Answer 1

class Foo {
public:
Foo(explicit int);
Foo& operator=(int);
};

Eso no es válido La sintaxis es

class Foo {
public:
explicit Foo(int);
Foo& operator=(int);
};

La diferencia es que el constructor de conversión no se puede usar para conversiones implícitas cuando se explicita antes:

Foo f(10); // works
Foo f = 10; // doesn''t work

Lo anterior no tiene nada que ver con un operador de asignación que haya declarado allí. No se usa, ya que es una inicialización (solo se usan constructores). Lo siguiente usará el operador de asignación:

Foo f;
f = 10;

Y usará el constructor predeterminado de Foo (el que no toma argumentos).

Editar : El interlocutor cambió su pregunta a las formas específicas de si

Foo f = 1; // called "copy initialization"
Foo f(1); // called "direct initialization"

Son lo mismo. La respuesta es que son equivalentes a lo siguiente:

Foo f(Foo(1));
Foo f(1);

Si y solo si el constructor de la conversión que toma el int no se declara con la palabra clave explicit , de lo contrario, el primero es un error del compilador (ver arriba). El compilador puede elide (optimizar) el temporal pasado al constructor de copia de Foo en el primer caso si todas las restricciones semánticas están todavía seguras, e incluso si el constructor de copia tiene efectos secundarios . Eso incluye especialmente un constructor de copia visible.

Answer 2

Foo f = 42;

Esta declaración hará un objeto temporal para el valor ''42''.

Foo f(42);

Esta declaración asignará directamente el valor para una llamada de función menos.