在继承期间构造方法调用层次结构 - 包含和不包含参数 [英] Constructor calling hierarchy during inheritance-both with and without parameters

问题描述

首先这不是重复的问题。

我知道事实：

• 在继承期间，构造函数的执行顺序与它们的派生顺序相同，并且析构函数的执行顺序与它们的派生顺序相反。


• 此外，我们可以在构造函数定义中使用 base 关键字来显式调用基类构造函数。

我的问题是：
下面的代码

  class ClassA 
 {
 public ClassA（int a）
 {
 Console.WriteLine（ClassA的参数化构造函数）; 
} 
} 
 class ClassB：ClassA 
 {
 public ClassB（int a）
 {
 Console.WriteLine（Parameterized Constructor of ClassB）; 
} 
} 
 class ClassC：ClassB 
 {
 public ClassC（int a）
 {
 Console.WriteLine（Parameterized Constructor of ClassC）; 
} 
} 
 
类程序
 {
 static void Main（string [] args）
 {
 ClassC classc =新ClassC（1）; 
 Console.ReadLine（）; 
} 
} 
  

我得到错误时间错误：

 'ClassA'不包含带有0个参数的构造函数
'ClassB'不包含带有0个参数的构造函数$但是当我将默认构造函数添加到这两个类时：
 
 $ b 
 
 



b $ b

  class ClassA 
 {
 public ClassA（）
 {
 Console.WriteLine（ClassA的默认构造函数） ; 
} 
 public ClassA（int a）
 {
 Console.WriteLine（ClassA的参数化构造函数）; 
} 
} 
 class ClassB：ClassA 
 {
 public ClassB（）
 {
 Console.WriteLine（ClassB的默认构造函数 ）; 
} 
 public ClassB（int a）
 {
 Console.WriteLine（ClassB的参数化构造函数）; 
} 
} 
 class ClassC：ClassB 
 {
 public ClassC（）
 {
 Console.WriteLine（ClassC的默认构造函数 ）; 
} 
 public ClassC（int a）
 {
 Console.WriteLine（ClassC的参数化构造函数）; 
} 
} 
 
类程序
 {
 static void Main（string [] args）
 {
 ClassC classc =新ClassC（1）; 
 Console.ReadLine（）; 
} 
} 
  

我得到了预期的输出。

A类的默认构造方法
B类的默认构造方法
ClassC的参数化构造方法


这意味着，在继承期间，所有基类都需要一个无参数的构造函数。

我没有得到任何清楚的解释。

解决方案

没有

  class ClassB：ClassA 
 {
 public ClassB（int a）
 {
 Console.WriteLine（ClassB ）; 
} 
} 
  

与

class ClassB：ClassA
{
public ClassB（int a）：base（）
{
控制台。 WriteLine（ClassB的参数化构造函数）;
}
}


编译器默认尝试调用基类的无参构造器。如果基类没有无参数构造函数，则必须自己显式调用它：

  class ClassB：ClassA 
 {
 public ClassB（int a）：base（a）
 {
 Console.WriteLine（ClassB的参数化构造函数）; 
} 
} 
  

此外，这与呼叫顺序无关构造函数。这发生在运行时。您正在遇到编译时问题。

First of all this is not a duplicate question.

I know the facts that:

• During inheritance, the order of execution of constructors will be in the same order as their derivation and order of execution of destructors will be in reverse order of their derivation.
• Also, we can call base class constructor explicitly using base keyword in constructor definition.

My question is : For my below code

class ClassA
{
    public ClassA(int a)
    {
        Console.WriteLine("Parameterized Constructor of ClassA");
    }
}
class ClassB : ClassA
{
    public ClassB(int a)
    {
        Console.WriteLine("Parameterized Constructor of ClassB");
    }
}
class ClassC : ClassB
{
    public ClassC(int a)
    {
        Console.WriteLine("Parameterized Constructor of ClassC");
    }
}

class Program
{
    static void Main(string[] args)
    {
        ClassC classc = new ClassC(1);
        Console.ReadLine();
    }
}

I am getting the complie time error:

'ClassA' does not contain a constructor that takes 0 arguments
'ClassB' does not contain a constructor that takes 0 arguments

But when I Add the default constructors to both the classes as :

class ClassA
{
    public ClassA()
    {
        Console.WriteLine("Default Constructor of ClassA");
    }
    public ClassA(int a)
    {
        Console.WriteLine("Parameterized Constructor of ClassA");
    }
}
class ClassB : ClassA
{
    public ClassB()
    {
        Console.WriteLine("Default Constructor of ClassB");
    }
    public ClassB(int a)
    {
        Console.WriteLine("Parameterized Constructor of ClassB");
    }
}
class ClassC : ClassB
{
    public ClassC()
    {
        Console.WriteLine("Default Constructor of ClassC");
    }
    public ClassC(int a)
    {
        Console.WriteLine("Parameterized Constructor of ClassC");
    }
}

class Program
{
    static void Main(string[] args)
    {
        ClassC classc = new ClassC(1);
        Console.ReadLine();
    }
}

I got the output as expected.

Default Constructor of ClassA
Default Constructor of ClassB
Parameterized Constructor of ClassC

SO does this means, During inheritance all base classes needs a parameterless constructor.

I didn't get any clear explanation for this yet. Please dont make this as duplicate and any good explanation is appreciated.

解决方案

No

class ClassB : ClassA
{
    public ClassB(int a)
    {
        Console.WriteLine("Parameterized Constructor of ClassB");
    }
}

is same as

class ClassB : ClassA
{
    public ClassB(int a):base()
    {
        Console.WriteLine("Parameterized Constructor of ClassB");
    }
}

Compiler by default tries to call parameterless constructor of base class. If the base class doesn't have a parameterless constructor, you have to explicitly call it yourself:

class ClassB : ClassA
{
    public ClassB(int a):base(a)
    {
        Console.WriteLine("Parameterized Constructor of ClassB");
    }
}

Also, this has nothing to do with order of calling the constructors. That happens in runtime. You are having compile-time issues.

这篇关于在继承期间构造方法调用层次结构 - 包含和不包含参数的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！