Constructor predeterminado - Default constructor

En los lenguajes de programación de computadoras , el término constructor predeterminado puede referirse a un constructor que es generado automáticamente por el compilador en ausencia de constructores definidos por el programador (por ejemplo, en Java), y generalmente es un constructor nular . En otros lenguajes (por ejemplo, en C ++) es un constructor que se puede llamar sin tener que proporcionar ningún argumento, independientemente de si el constructor es autogenerado o definido por el usuario. Tenga en cuenta que aún se puede llamar a un constructor con parámetros formales sin argumentos si se proporcionaron argumentos predeterminados en la definición del constructor.

C ++

En C ++ , el estándar describe el constructor predeterminado para una clase como un constructor que se puede llamar sin argumentos (esto incluye un constructor cuyos parámetros tienen todos argumentos predeterminados). Por ejemplo:

class MyClass
{
public:
    MyClass();  // constructor declared

private:
    int x;
};

MyClass::MyClass() : x(100)  // constructor defined
{
}

int main()
{
    MyClass m;  // at runtime, object m is created, and the default constructor is called
}

Cuando se asigna memoria dinámicamente, se puede llamar al constructor agregando paréntesis después del nombre de la clase. En cierto sentido, esta es una llamada explícita al constructor:

int main()
{
    MyClass * pointer = new MyClass();  // at runtime, an object is created, and the
                                        // default constructor is called
}

Si el constructor tiene uno o más parámetros, pero todos tienen valores predeterminados, sigue siendo un constructor predeterminado. Recuerde que cada clase puede tener como máximo un constructor predeterminado, ya sea uno sin parámetros, o uno cuyos parámetros tengan valores predeterminados, como en este caso:

class MyClass
{
public:
    MyClass (int i = 0, std::string s = "");  // constructor declared

private:
    int x;
    int y;
    std::string z;
};

MyClass::MyClass(int i, std::string s)     // constructor defined
{
    x = 100;
    y = i;
    z = s;
}

En C ++, los constructores predeterminados son importantes porque se invocan automáticamente en determinadas circunstancias; y por lo tanto, en estas circunstancias, es un error que una clase no tenga un constructor predeterminado:

• Cuando el valor de un objeto se declara sin lista de argumentos (por ejemplo MyClass x; :) o se asigna dinámicamente sin lista de argumentos (por ejemplo: new MyClass; o new MyClass(); ), el constructor predeterminado de MyClass se utiliza para inicializar el objeto.
• Cuando se declara una matriz de objetos, por ejemplo MyClass x[10]; ; o asignados dinámicamente, por ejemplo new MyClass [10] . El constructor predeterminado de MyClass se usa para inicializar todos los elementos.
• Cuando un constructor de clase derivada no llama explícitamente al constructor de clase base en su lista de inicializadores, se llama al constructor predeterminado para la clase base.
• Cuando un constructor de clase no llama explícitamente al constructor de uno de sus campos con valores de objeto en su lista de inicializadores, se llama al constructor predeterminado para la clase del campo.
• En la biblioteca estándar, ciertos contenedores "completan" los valores usando el constructor predeterminado cuando el valor no se da explícitamente. Por ejemplo, vector<MyClass>(10); inicializa el vector con diez elementos, que se rellenan con un MyClass objeto construido por defecto .

Si una clase no tiene constructores definidos explícitamente, el compilador declarará y definirá implícitamente un constructor predeterminado para ella. Este constructor predeterminado definido implícitamente es equivalente a uno definido explícitamente con un cuerpo vacío. Por ejemplo:

class MyClass
{
    int x;  // no constructor, so the compiler produces an (implicit) default constructor
};

int main()
{
    MyClass m;   // no error at runtime: the (implicit) default constructor is called
}

Si los constructores se definen explícitamente para una clase, pero todos no son predeterminados, el compilador no definirá implícitamente un constructor predeterminado, lo que lleva a una situación en la que la clase no tiene un constructor predeterminado. Esta es la razón de un error típico, demostrado por el siguiente ejemplo.

class MyClass
{
public:
    MyClass (int y);  // declaration a non-default constructor

private:
    int x;
};

MyClass::MyClass (int y)
{
    x = y;
}

int main()
{
    MyClass m(100);     // the non-default constructor is called
    MyClass * p;        // for pointer declarations, the compiler does not need to know about constructors
    p = new MyClass();  // error at compilation: no default constructor
    return 0;
}

Dado que ni el programador ni el compilador han definido un constructor predeterminado, la creación del objeto objetado al que apunta p conduce a un error.

Por otro lado, en C ++ 11 se puede crear explícitamente un constructor predeterminado:

class MyClass
{
public:
    MyClass () = default;  // force generation of a default constructor
};

O explícitamente inhibido:

class MyClass
{
public:
    MyClass () = delete;  // prevent generation of default constructor
};

Java y C #

Tanto en Java como en C # , un "constructor predeterminado" se refiere a un constructor nular que el compilador genera automáticamente si no se han definido constructores para la clase. El constructor predeterminado llama implícitamente al constructor nular de la superclase y luego ejecuta un cuerpo vacío. Todos los campos se dejan en su valor inicial de 0 (tipos enteros), 0.0 (tipos de punto flotante), false ( boolean tipo) o null (tipos de referencia). Un constructor definido por el programador que no toma parámetros también se denomina constructor predeterminado en C # , pero no en Java .

Referencias