C++子类显示调用父类的构造函数

C++子类显示调用父类的构造函数

加入有父类是这样定义的:

class CA {  
public:  
    CA() { 
           cout << "using ca's constractor/n"; 
         }  
    CA(int k) {
                cout << "using ca's 2nd constractor, k is " << k << endl; 
                m = k;
              };  
    virtual ~CA() {
                    cout << "using ca's disconstractor/n"; 
                  }  
    void output() {
                    cout << "the m is " << m << endl; 
                  }  
private:  
    int m;
};

注意A类里面有一个私有成员m.

 

假设有一个子类是这样定义的：

class CB : public CA {  
public:  
    CB(int k) { m = k; }  
};

显然是错误的，B类不可以直接访问A类的成员m

 

这样定义也是错误的:

class CB : public CA {  
public:  
    CB(int k) { __super::CA((int)k); }  
};

这样其实是在CB(int k)中构造了一个CA类的临时变量实例，函数执行完以后就没有了。若是有：

CB b(2);  
执行的结果是：

using ca's constractor
using ca's 2nd constractor, k is 2
using ca's disconstractor
using ca's disconstractor

这说明，先默认的调用CA()构造了一个CB的实例，而后又声明了一个CA (2)的实例。

 

正确的方法是这样的:

class CB:public CA {  
 public:
CB(int k):CA(k)
{
.....
} 
};

这就是在子类中显示调用父类的构造函数。

-------------------------------------

在C++中子类继承和调用父类的构造函数方法

    构造方法用来初始化类的对象，与父类的其它成员不一样，它不能被子类继承（子类能够继承父类全部的成员变量和成员方法，但不继承父类的构造方法）。所以，在建立子类对象时，为了初始化从父类继承来的数据成员，系统须要调用其父类的构造方法。

    若是没有显式的构造函数，编译器会给一个默认的构造函数，而且该默认的构造函数仅仅在没有显式地声明构造函数状况下建立。

构造原则以下：

1. 若是子类没有定义构造方法，则调用父类的无参数的构造方法。

2. 若是子类定义了构造方法，不管是无参数仍是带参数，在建立子类的对象的时候,首先执行父类无参数的构造方法，而后执行本身的构造方法。

3. 在建立子类对象时候，若是子类的构造函数没有显示调用父类的构造函数，则会调用父类的默认无参构造函数。

4. 在建立子类对象时候，若是子类的构造函数没有显示调用父类的构造函数且父类本身提供了无参构造函数，则会调用父类本身的无参构造函数。

5. 在建立子类对象时候，若是子类的构造函数没有显示调用父类的构造函数且父类只定义了本身的有参构造函数，则会出错（若是父类只有有参数的构造方法，则子类必须显示调用此带参构造方法）。

6. 若是子类调用父类带参数的构造方法，须要用初始化父类成员对象的方式，好比：

#include <iostream.h>
　　class animal
　　{
　　public:
　　　　animal(int height, int weight)
　　　　{
　　　　　　cout<<"animal construct"<<endl;
　　　　}
　　　　…
　　};

　　class fish:public animal
　　{
　　public:
　　　　fish():animal(400,300)
　　　　{
　　　　　　cout<<"fish construct"<<endl;
　　　　}
　　　　…
　　};
　　void main()
　　{
　　　　fish fh;
　　}

　　在fish类的构造函数后，加一个冒号（:），而后加上父类的带参数的构造函数。这样，在子类的构造函数被调用时，系统就会去调用父类的带参数的构造函数去构造对象。这种初始化方式，还经常使用来对类中的常量（const）成员进行初始化，以下面的代码所示：

　　class point
　　{
　　public:
　　　　 point():x(0),y(0)
　　private:
　　　　 const int x;
　　　　 const int y;
　　};

　　固然，类中普通的成员变量也能够采起此种方式进行初始化，然而，这就没有必要了。