¿Por qué es necesario que una clase base tenga un constructor que tome 0 argumentos?

Question

Esto no compilará:

namespace Constructor0Args 
{ 
    class Base 
    { 
     public Base(int x) 
     { 
     } 
    } 

    class Derived : Base 
    { 
    } 

    class Program 
    { 
     static void Main(string[] args) 
     { 
     } 
    } 
} 

En cambio, me sale el siguiente error:

'Constructor0Args.Base' does not contain a constructor that takes 0 arguments

¿Por qué? ¿Es necesario que una clase base tenga un constructor que tome 0 argumentos?

Answer 1

se no es - el problema es que tiene que llamar a algunos constructor base, para inicializar el tipo de base, y el predeterminado es llamar al base(). Se pueden ajustar que especificando el constructor específica (y argumentos) a sí mismo en el tipos de derivados constructor:

class Derived : Base 
{ 
    public Derived() : base(123) {} 
} 

Para los parámetros a base (o, alternativamente, this) constructores, se puede utilizar:

• parámetros al constructor actual
• literales/constantes
• llamadas a métodos estáticos (también involucra la anterior)

Por ejemplo, la siguiente es también válida, utilizando los tres puntos anteriores:

class Derived : Base 
{ 
    public Derived(string s) : base(int.Parse(s, NumberStyles.Any)) {} 
} 

Answer 2

Si no se define explícitamente un constructor para una clase, un constructor por defecto se define de forma automática, con la apariencia siguiente:

public Derived() : base() 
{ 
} 

es necesario especificar el constructor de la clase base, así como el que los argumentos para pasar a ella:

public Derived() : base(1) 
{ 
} 

Answer 3

Al derivar una clase de otra, la clase base será llamado antes de que el constructor de clases derivadas. Cuando no llamar explícitamente un constructor que son esencialmente escribiendo

Puesto que la clase Base no tiene un constructor 0 argumento, esto no es válido.

Answer 4

Esto se debe a que cuando se crea una instancia de la clase hija, también creará una instancia de la clase base. Por defecto, intentará encontrar un constructor arg menos. Este es el trabajo con este código:

class Base 
    { 
     public Base(int x) { } 
    } 
    class Derived : Base 
    { 
     public Derived(int x) 
      : base(x) 
     { 
     } 
    }