C++笔记：关于基类、派生类的构造

 

       创建派生类对象时，先自动创建一个基类对象，调用基类构造函数，然后调用派生类构造函数；派生类生命周期结束时，先调用派生类的析构函数，然后调用基类的析构函数；另外注意：类的构造函数不能被继承

 

来看一个最简单的例子：

#include<bits/stdc++.h>
using namespace std;

class A
{
  public:
     A(){cout<<"i am a\n";}
     ~A(){cout<<"a is over\n";};
  private:
     int n;

};

class B:public A
{
    public:
        B(){cout<<"i am b\n";}
        ~B(){cout<<"b is over\n";}
};

class C:public B
{
    public:
        C(){cout<<"i am c\n";}
        ~C(){cout<<"c is over\n";}
};

int main()
{
  A a;
  B b;
  C c;
  return 0;
}

 

 

以上是最简单的不带参数的情况，下面讨论复杂点的情况

既然构造函数不能被继承，派生类所继承的基类成员必须自己初始化

但问题在于大部分基类都有private成员变量，派生类根本无法访问，从而也不可能用派生类的构造函数初始化

C++解决办法：在派生类的构造函数中调用基类的构造函数

 

首先看一个简单的例子

 

#include<bits/stdc++.h>
using namespace std;

class A
{
  public:
     A(){cout<<"i am a\n";}
     ~A(){cout<<"a is over\n";};
  private:
     int n;

};

class B:public A
{
    public:
        B(){cout<<"i am b\n";}
        B(int n){num=n;cout<<"i am also b\n";}
        ~B(){cout<<"b is over\n";}
    private:
        int num;
};

int main()
{
  A a;
  B b(4);
  return 0;
}

 

这时隐式调用了基类无参数的构造函数

如果这样写也没问题：

#include<bits/stdc++.h>
using namespace std;

class A
{
  public:
     ~A(){cout<<"a is over\n";};
  private:
     int num;

};

class B:public A
{
    public:
        B(){cout<<"i am b\n";}
        B(int n){num=n;cout<<"i am also b\n";}
        ~B(){cout<<"b is over\n";}
    private:
        int num;
};

int main()
{
  A a;
  B b(4);
  return 0;
}

运行结果：

 

因为如果定义一个对象时没有提供构造函数，编译器会使用默认构造函数；所以虽然屏幕上没有显示，但调用了默认的基类构造函数

 

但是这样写会出问题：

#include<bits/stdc++.h>
using namespace std;

class A
{
  public:
     //A(){}
     A(int n){num=n;cout<<"i am also a\n";}//ERROR!
     ~A(){cout<<"a is over\n";};
  private:
     int num;

};

class B:public A
{
    public:
        B(){cout<<"i am b\n";}
        B(int n){num=n;cout<<"i am also b\n";}
        ~B(){cout<<"b is over\n";}
    private:
        int num;
};

int main()
{
  A a;
  B b(4);
  return 0;
}

 

 

这里回到了默认构造函数那个老问题，我们先撇开派生类不谈

如果定义了一个类，没有构造函数（一个都没有），编译器会使用默认构造函数，你可以直接创建一个对象a，直接A a;

但是一旦定义了构造函数，创建对象的时候编译器就会根据定义时的参数列表寻找最匹配的构造函数，如果它没有找到最合适的（你有构造函数，但是没有适合我的）就会报错

 

#include<bits/stdc++.h>
using namespace std;

class A
{
  public:
     A(){cout<<"i am a\n";}
     A(int n){num=n;cout<<"i am a-num\n";}
     A(char c){cc=c;cout<<"i am a-char\n";}
     ~A(){cout<<"a is over\n";};
  private:
     int num;
     char cc;

};

int main()
{
  A a('l'),b(12);
  return 0;
}

运行结果：

 

对比：

#include<bits/stdc++.h>
using namespace std;

class A
{
  public:
     A(){cout<<"i am a\n";}
     A(int n){num=n;cout<<"i am a-num\n";}
     //A(char c){cc=c;cout<<"i am a-char\n";}
     void print(){cout<<num<<endl;}
     ~A(){cout<<"a is over\n";};
  private:
     int num;
     char cc;

};

int main()
{
  A a('1'),b(12);
  a.print();//ACS II of '1'
  b.print();
  return 0;
}

结果：

 下面程序报错：

#include<bits/stdc++.h>
using namespace std;

class A
{
  public:
     A(){cout<<"i am a\n";}
     A(int n){num=n;cout<<"i am a-num\n";}
     A(char c){cc=c;cout<<"i am a-char\n";}
     void print(){cout<<num<<endl;}
     ~A(){cout<<"a is over\n";};
  private:
     int num;
     char cc;

};

int main()
{
  A a("lalala");//no matching function!
  return 0;
}

 

这就需要我们考虑以参数列表的形式显式调用基类构造函数：

#include<bits/stdc++.h>
using namespace std;

class A
{
  public:
     A(int n){num=n;cout<<"i am also a\n";}
     ~A(){cout<<"a is over\n";}
     void print(){cout<<"The number is:"<<num<<endl;}
  private:
     int num;

};

class B:public A
{
    public:
        B(int m,int n):A(m){num=n;cout<<"i am also b\n";}
        ~B(){cout<<"b is over\n";}
        void print(){cout<<"The number is:"<<num<<endl;}
    private:
        int num;
};

int main()
{
  B b(2,3);
  b.print();
  b.A::print();
  return 0;
}

运行结果:

 

 

下面简单介绍函数初始化列表：

《C++ Primer》中提到在以下三种情况下需要使用构造函数初始化列表

   1）需要初始化的类的成员变量是对象的情况； 

   2）需要初始化的类的成员变量由const修饰的或初始化的类的引用成员变量；

   3)  派生类初始化基类的成员

这里就主要涉及到第三点，派生类初始化基类的成员变量，需要在(也只能在)参数初始化列表中显式调用基类的构造函数；另外，如果不用初始化列表，进入构造函数体后，进行成员变量的赋值操作，赋值和初始化效率是不同的，类对自己的成员进行一次隐式的默认构造函数的调用和一次赋值操作运算符的调用，当类中成员较多时，这样效率会很低

注意：构造函数需要初始化的数据成员，不论是否显式出现在成员初始化列表中，都会在该处完成初始化，初始化顺序与其在类中的声明顺序一致，与列表的顺序无关

格式：
classname::classname(parameterlist):baseclassname(argumentlist),member1(argumentlist),member2(argumentlist)...{ }

实例：

#include<bits/stdc++.h>
using namespace std;

class A
{
  public:
      A(int n1,int n2){num1=n1;num2=n2;}
      void print(){cout<<"num1:"<<num1<<' '<<"num2:"<<num2<<endl;}
  public:
      int num1,num2;

};

class B:public A
{
    public:
        B(int n1,int n2,int n3,int n4);
        void print(){cout<<"num1:"<<num1<<' '<<"num2:"<<num2<<endl;}
    private:
        int num1,num2;
};
B::B(int n1,int n2,int n3,int n4):A(n1,n2),num1(n3),num2(n4){}

int main()
{
  B b(2,3,4,5);
  b.A::print();28   b.print();
  return 0;
}

运行结果：

 

基本就这些，大佬们不吝赐教鸭~

参考链接：

 https://blog.csdn.net/baiyu9821179/article/details/69397673

 https://blog.csdn.net/linger2012liu/article/details/24721321

 https://blog.csdn.net/baidu_35679960/article/details/80713457

 https://blog.csdn.net/liguoying521/article/details/84623766