将基类构造函数强制转换为派生类构造函数是什么意思?

what is the meaning in casting base class constructor to derived class constructor?

本文关键字：构造函数 是什么 意思 派生 转换 基类      更新时间：2023-10-16
class Triangle: public Shape{
      public:
             Triangle(int a=0, int b=0):Shape(a,b){}
             int area()
             {
                 cout << "in triangle class";
                 return width*height/2;
             }
};
上面代码中的

， wt是

行的含义。
Triangle(int a=0, int b=0):Shape(a,b){}

如果Derived类继承了Base类，那么在构造Derived对象时，Derived类的构造函数必须调用Base类的构造函数。这些类的Destructor将以相反的顺序调用。在Triangle(int a=0, int b=0):Shape(a,b){}中，Triangle构造函数调用Shape构造函数并传递所需的参数。不涉及选角。检查这个和这个

这里没有强制转换。Triangle构造函数用参数列表(a,b)调用Shape基类的构造函数。

这里没有强制转换。这是一个构造函数初始化列表。

当你构造Triangle时，由于Shape是一个基类，它必须先构造Shape。列表Shape(a,b)说明a,b是给这个Shape的构造函数的参数。

代码:

class Triangle: public Shape{
      public:
             Triangle(int a=0, int b=0):Shape(a,b)
             {
               // may do something
             }
             int area()
             {
                 cout << "in triangle class";
                 return width*height/2;
             }
};

内部如何工作:

class Triangle: public Shape{
          public:
                     Triangle(int a=0, int b=0):
                 {
                   // always before the others instructions
                   base(a,b);
                   // may do something
                 }
                 int area()
                 {
                     cout << "in triangle class";
                     return width*height/2;
                 }
    };
有几种方法可以使用构造函数:

(1)用新的构造函数声明一个新类

class NewConstructorClass: public SomeBaseClass // dont care about parent class constructor
{
   NewConstructorClass {
     // do something new instruction 1
     // do something new instruction 2
     // do something new instruction 3
   }
  public:
    void DoAnything()
    {
      // ...
    }
};

(2)用一个新的空构造函数声明一个新类。一些开发人员这样做，是为了稍后向构造函数中添加代码，或者显式地添加一个空构造函数，作为"最佳实践"，表明应该有一个构造函数。

class NewConstructorClass: public SomeBaseClass // dont care about parent class constructor
{
   NewConstructorClass {
     // does nothing, on purpouse
   }
  public:
    void DoAnything()
    {
      // ...
    }
};

(3)声明一个没有新构造函数的新类。编译器添加了一个不做任何事情的自动构造函数。

class NewConstructorClass: public SomeBaseClass // dont care about parent class constructor
{
   NewConstructorClass {
     // do something new
   }
  public:
    void DoAnything()
    {
      // ...
    }
};

(4)声明一个带有新构造函数的新类，该构造函数调用基构造函数。就像你的场景:

class NewConstructorClass: public SomeBaseClass // dont care about parent class constructor
{
   NewConstructorClass: base() {
     // do something new
   }
  public:
    void DoAnything()
    {
      // ...
    }
};

每种情况都取决于你想要达到的目标。根据编码风格的不同，这些情况中的一些可能被认为是"坏实践"，另一些则是"好实践"。

欢呼。

相关文章：