C++ - construcción de un objeto dentro de una clase

Question

Soy bastante nuevo en C++, y no estoy seguro de este. Eche un vistazo al siguiente ejemplo que resume mi problema actual.

class Foo 
{ 
    //stuff 
}; 

class Bar 
{ 
    Foo foo; 
}; 

So Bar constata un objeto Foo completo, no solo una referencia o un puntero. ¿Este objeto está inicializado por su constructor predeterminado? ¿Debo llamar explícitamente su constructor y, de ser así, cómo y dónde?

Gracias.

Answer 1

Se ha inicializado por su Constructor predeterminado. Si desea utilizar un constructor diferente, es posible que tenga algo como esto:

class Foo 
{ 
    public: 
    Foo(int val) { } 
    //stuff 
}; 

class Bar 
{ 
    public: 
    Bar() : foo(2) { } 

    Foo foo; 
}; 

Answer 2

So Bar constains a full Foo object, not just a reference or pointer. Is this object initialized by its default constructor?

Si Foo tiene una ctor defecto, un objeto de tipo Foo va a utilizar el ctor por defecto cuando se crea un objeto de tipo Bar. De lo contrario, debe llamar al Foo ctor usted mismo o su codificador Bar hará que su compilador se queje in situ.

Ej:

class Foo { 
public: 
Foo(double x) {} 
}; 

class Bar { 
Foo x; 
}; 

int main() { 
Bar b; 
} 

Lo anterior tendrá el compilador se queja algo como:

"In constructor 'Bar::Bar()': Line 5: error: no matching function for call to 'Foo::Foo()'

Do I need to explicitly call its constructor, and if so, how and where ?

Modificar el ejemplo anterior de la siguiente manera:

class Foo { 
public: 
    Foo(double x) {} // non-trivial ctor 
}; 

class Bar {  
Foo x; 
public: 
    Bar() : x(42.0) {} // non-default ctor, so public access specifier required 
}; 

int main() { 
Bar b; 
} 

Answer 3

Si usted no llama explícitamente un constructor de foo interior del constructor del bar, el que viene por defecto será utilizado. Esto se puede controlar mediante una llamada explícita al constructor

Bar::Bar() : foo(42) {} 

Esto es, por supuesto, asumiendo que se agrega una Foo :: foo (int) para el código :)

Answer 4

objeto completo. No, está construido por defecto en el constructor predeterminado de Bar.

Ahora, si Foo tuviera un constructor que solo tomara, digamos, un int. Se necesitaría un constructor en Bar llamar al constructor de Foo, y decir lo que es:

class Foo { 
public: 
    Foo(int x) { .... } 
}; 

class Bar { 
public: 
    Bar() : foo(42) {} 

    Foo foo; 
}; 

Pero si Foo tenía un constructor por defecto Foo(), el compilador genera el constructor del bar de forma automática, y que llamarían por defecto de Foo (es decir, Foo())

Answer 5

A menos que especifique lo contrario, foo se inicializa utilizando su constructor predeterminado. Si desea utilizar algún otro constructor, es necesario hacerlo en la lista de inicialización para Bar:

Bar::Bar(int baz) : foo(baz) 
{ 
    // Rest of the code for Bar::Bar(int) goes here... 
} 

Answer 6

No es necesario llamar al contructor por defecto de forma explícita en C++, que se llamará para usted. Si usted quiere llamar a un contructor diferente, usted puede hacer esto:

Foo foo(somearg) 

Answer 7

Hay cuatro funciones compilador de C++ generará para cada clase, si se puede, y si no les proporcionan: un constructor por defecto , un constructor de copia, un operador de asignación y un destructor.En el Estándar de C++ (capítulo 12, "Funciones especiales"), estos se conocen como "declarados implícitamente" e "implícitamente definidos". Tendrán acceso público.

No confunda "implícitamente definido" con "predeterminado" en un constructor. El constructor predeterminado es el que se puede llamar sin ningún argumento, si hay uno. Si no proporciona ningún constructor, se definirá implícitamente uno predeterminado. Utilizará los constructores por defecto para cada clase base y miembro de datos.

Entonces, lo que sucede es que la clase Foo tiene un constructor predeterminado definido implícitamente, y Bar (que no parece tener un constructor definido por el usuario) usa su constructor predeterminado definido implícitamente que llama al constructor predeterminado de Foo.

Si desea escribir un constructor para Bar, puede mencionar a foo en su lista de inicializadores, pero como está utilizando el constructor predeterminado, no tiene que especificarlo.

Recuerde que, si escribe un constructor para Foo, el compilador no generará automáticamente un constructor predeterminado, por lo que tendrá que especificar uno si necesita uno. Por lo tanto, si pusiera algo como Foo(int n); en la definición de Foo y no escribiera explícitamente un constructor predeterminado (Foo(); o), no podría tener una barra en su forma actual, ya que no podría usar Constructor por defecto de Foo. En este caso, tendrías que tener un constructor como Bar(int n = 0): foo(n) {} que tenga el constructor de Bar para inicializar el Foo. (Tenga en cuenta que Bar(int n = 0) {foo = n;} o similar no funcionaría, ya que el constructor de barras primero intentaría inicializar foo, y eso fallaría.)

Answer 8

La construcción es un tema bastante difícil en C++. La respuesta simple es depende. Si Foo se inicializa o no depende de la definición de Foo. Sobre la segunda pregunta: cómo hacer que Bar inicialice Foo: listas de inicialización son la respuesta.

Aunque el consenso general es que Foo se inicializará por defecto mediante el constructor predeterminado implícito (compilador generado), no es necesario que sea verdadero.

Si Foo no tiene un constructor predeterminado definido por el usuario, entonces Foo no se inicializará. Para ser más precisos: cada miembro de la barra o del Foo carecen de una definida por el usuario constructor por defecto será inicializada por el compilador genera constructor por defecto de la barra:

class Foo { 
    int x; 
public: 
    void dump() { std::cout << x << std::endl; } 
    void set() { x = 5; } 
}; 
class Bar { 
    Foo x; 
public: 
    void dump() { x.dump(); } 
    void set() { x.set(); } 
}; 
class Bar2 
{ 
    Foo x; 
public: 
    Bar2() : Foo() {} 
    void dump() { x.dump(); } 
    void set() { x.set(); } 
}; 
template <typename T> 
void test_internal() { 
    T x; 
    x.dump(); 
    x.set(); 
    x.dump(); 
} 
template <typename T> 
void test() { 
    test_internal<T>(); 
    test_internal<T>(); 
} 
int main() 
{ 
    test<Foo>(); // prints ??, 5, 5, 5, where ?? is a random number, possibly 0 
    test<Bar>(); // prints ??, 5, 5, 5 
    test<Bar2>(); // prints 0, 5, 0, 5 
} 

Ahora, si Foo tenía un constructor definido por el usuario y luego lo haría inicializarse siempre, independientemente de si Bar tiene o no un constructor inicializado por el usuario. Si Bar tiene un constructor definido por el usuario que explícitamente llama al constructor (posiblemente implícitamente definido) de Foo, entonces Foo se inicializará. Si la lista de inicialización de Bar no llama al constructor Foo, entonces será equivalente al caso en que Bar no tenga un constructor definido por el usuario.

El código de la prueba puede necesitar algunas explicaciones. Estamos interesados ​​en si el compilador inicializa la variable sin que el código de usuario realmente llame al constructor. Queremos probar si el objeto está inicializado o no. Ahora bien, si simplemente creamos un objeto en una función, es posible que golpee una posición de memoria que no se haya tocado y que ya contenga ceros. Queremos diferenciar la suerte del éxito, por lo que definimos una variable en una función y llamamos a la función dos veces. En la primera ejecución, imprimirá los contenidos de la memoria y forzará un cambio. En la segunda llamada a la función, dado que el seguimiento de la pila es el mismo, la variable se mantendrá exactamente en la misma posición de memoria. Si se inicializó, se establecería en 0, de lo contrario mantendría el mismo valor que tenía la variable anterior en exactamente la misma posición.

En cada una de las ejecuciones de prueba, el primer valor impreso es el valor inicializado (si realmente se inicializó) o el valor en esa posición de memoria, que en algunos casos es 0. El segundo valor es solo una prueba token que representa el valor en la posición de memoria después de cambiarlo manualmente. El tercer valor proviene de la segunda ejecución de la función. Si la variable se está inicializando, retrocederá a 0. Si el objeto no se inicializa, su memoria mantendrá los contenidos anteriores.