C++继承关系之子类的六个成员函数

默认成员函数
在继承关系里面， 在派生类中如果没有显示定义下列六个成员函数， 编译系统则会默认合成这六个默认的成员函数。

上图：

这篇文章会详细介绍构造函数，析构函数，拷贝构造函数和赋值运算符的重载。
因为另外两个在我们这个阶段基本上不用到，所以只要大概知道有这么个东西就行(说白了就是我也不会。。。)
下面我们先讲：

构造函数和析构函数

构造函数和析构函数概念的东西就不用过多解释了吧，应该都懂。。直接上代码

代码块：

#define _CRT_SECURE_NO_WARNINGS 1
#include<iostream>
#include<stdio.h>
using namespace std;
class base
{
public:
 base()
 {
  cout << "base()" << endl;
 }
 ~base()
 {
  cout << "~base()" << endl;
 }
 int pub;
protected:
 int pro;
private:
 int pri;
};
class Derive:public base
{
public:
 Derive()
 {
  cout << "Derive()" << endl;
 }
 ~Derive()
 {
  cout << "~Derive()" << endl;
 }
 int _pub;
protected:
 int _pro;
private:
 int _pri;
};
void Test()//析构函数只在函数体结束时候调用，所以在main函数里声明不好看到析构函数
{
 Derive d;
}
int main()
{
 Test();
 system("pause");
 return 0;
}

运行结果：

分析：我们创建了一个派生类Derived对象d，从运行结果可以看出，创建对象过程是：先调用基类的构造函数，再调用子类的构造函数；而析构对象时,是先调用子类的析构函数，再调用基类的析构函数。

But...
实际上是，先调用子类的构造函数，子类又继承了父类，所以父类的构造函数是在子类的初始化列表里面被调用的。

 

跳到转汇编：
截图一：

截图二：

 

 

截图三：

进行汇编单步调试之后，图一：光标先移动到子类构造函数中去，在构造函数还没进入cout("derive()"),图二：先call了"00C53765  call        base::base (0C514BFh)", 图三：然后跳转进 base的构造函数中去

所以说base()这一动作是在子类析构函数的初始化列表上完成的。
总结：
1.因为是在栈上创建的对象，所以符合栈后进先出的特性。
2.多继承同理，只是两个父类对象，按照先声明的先构造。

拷贝构造函数：(单参)

注意区分：构造函数是创建新的对象并初始化。

                 拷贝构造函数是利用已有对象来初始化这个新对象。

调用拷贝构造函数的三种情况：
1.使用一个已有对象来初始化这个准备创建的对象。
2.函数(形)参数是类的对象，调用函数生成类的临时对象。
3.函数返回值是对象的时候，函数执行完返回时初始化一个无名对象。

参数：类 类型对象的引用 const base&            为什么是引用呢。？

           原因是如果传值的话，这个是默认的成员函数，所以每次创建一个临时对象的时候就会调用这个函数，然后又要创建新的             临时对象，所以咯，陷入了死循环。。 

代码块：

#define _CRT_SECURE_NO_WARNINGS 1
#include<iostream>
#include<stdio.h>
using namespace std;
class base
{
public:
 base(int a=1,int b=2,int c=3)//构造函数
  : pub(a)
  , pro(b)
  , pri(c)
 {
  cout << "base()" << endl;
 }
 base(base& b1)//拷贝构造函数
 {
  pub = b1.pub;
  pro = b1.pro;
  pri = b1.pri;
  cout << "copy constructor"<<endl;
 }
 ~base()//析构函数
 {
  cout << "~base()" << endl;
 }
 void dis()
 {
  cout << "dis()" << endl;
  cout << "    pub=" << pub;
  cout << "    pro=" << pro;
  cout << "    pri=" << pri<<endl;;
 }
 //对象做参数，返回值------结合截图分析效果会更佳哦
 base func(base b3)//第三个拷贝构造出一个临时变量
 {
  int x;
  int y;
  int z;
  cout << "func()" << endl;//输出
  x = b3.pub + 10;
  y = b3.pro + 10;
  z = b3.pri + 10;
  base b4(x, y, z);//构造函数
  return b4;//函数执行完返回一个base类对象，第四个拷贝构造初始化一个无名对象
 }//函数体结束，依次析构在函数体里创建的三个对象
 int pub;
protected:
 int pro;
private:
 int pri;
};

int main()
{
 base b;//构造函数
 b.dis();//函数调用
 base p(b);//第一个拷贝构造函数
 base p1 = b;//第二个拷贝构造函数
 p1 = p.func(p);//进来说
 p1.dis();
 system("pause");
 return 0;
}

运行结果：

    万一程序没有显式定义拷贝构造函数，编译器将会自动生成一个。
    如果想在派生类中构造基类对象，那么不仅仅可以用构造函数，也可以用拷贝构造函数；

最后一个主题：

赋值运算符重载

 

类似于拷贝构造函数，拷贝构造函数使用一个已有对象来初始化这个准备创建的对象。(有新对象生成)
赋值运算符的重载是对一个已存在的对象进行拷贝赋值。(没有新对象生成)

代码块：

#define _CRT_SECURE_NO_WARNINGS 1
#include<iostream>
#include<stdio.h>
using namespace std;
class base
{
public:
 base(int a=1,int b=2,int c=3)
  : pub(a)
  , pro(b)
  , pri(c)
 {
  cout << "base()" << endl<<endl;
 }
 /*base(base& b1)//拷贝构造函数已被注释
 {
  pub = b1.pub;
  pro = b1.pro;
  pri = b1.pri;
  cout << "copy constructor"<<endl;
 }*/
 base& operator= (const base& b1)//赋值运算符重载函数，时刻记得类的成员函数里面第一个参数总是this指针哦
 {
  if (this != &b1)//先确认不是自己给自己赋值
  {
   cout << "base& operator=(const base& b1)" << endl<<endl;
   pub = b1.pub;
   pro = b1.pro;
   pri = b1.pri;
  }
  return *this;//因为this是指针，所以要解引用
 }
 ~base()
 {
  cout << "~base()" << endl;
 }
 void dis()
 {
  cout << "dis()" << endl;
  cout << "    pub=" << pub;
  cout << "    pro=" << pro;
  cout << "    pri=" << pri << endl<<endl;;
 }
 int pub;
protected:
 int pro;
private:
 int pri;
};

int main()
{
 base b(10,20,30);//构造函数，给出参数的话，则使用参数（10，20，30）
 b.dis();//函数调用
 base p;//构造函数，没有给出参数，则使用默认缺省参数（1，2，3）
 p.dis();//函数调用
 p = b;//赋值运算符重载
 p.dis();//重载后再次函数调用
 system("pause");
 return 0;
}

运行结果：

考虑一下..要是子类给父类进行运算符重载呢。？

代码块：

#define _CRT_SECURE_NO_WARNINGS 1
#include<iostream>
#include<stdio.h>
using namespace std;
class base//父类
{
public:
 base(int a=1,int b=2,int c=3)//初始化列表------全缺省
  : pub(a)
  , pro(b)
  , pri(c)
 {
  cout << "base()" << endl<<endl;
 }
 /*base(base& b1)//已被注释的拷贝构造函数
 {
  pub = b1.pub;
  pro = b1.pro;
  pri = b1.pri;
  cout << "copy constructor"<<endl;
 }*/
 base& operator= (const base& b1)//正在使用的赋值运算符重载函数
 {
  if (this != &b1)
  {
   cout << "base& operator=(const base& b1)" << endl<<endl;
   pub = b1.pub;
   pro = b1.pro;
   pri = b1.pri;
  }
  return *this;
 }
 ~base()
 {
  cout << "~base()" << endl;
 }
 void dis()
 {
  cout << "dis()" << endl;
  cout << "    pub=" << pub;
  cout << "    pro=" << pro;
  cout << "    pri=" << pri << endl<<endl;;
 }
 int pub;
protected:
 int pro;
private:
 int pri;
};
class Derive:public base//子类，公有继承
{
public:
 Derive(int a=4,int b=5,int c=6)//同上，初始化列表全缺省
  : _pub(a)
  , _pro(b)
  , _pri(c)
 {
  cout << "Derive()" << endl;
 }
 ~Derive()
 {
  cout << "~Derive()" << endl;
 }
 void dis()
 {
  cout << "dis()" << endl;
  cout << "    pub=" << _pub;
  cout << "    pro=" << _pro;
  cout << "    pri=" << _pri << endl << endl;;
 }
 int _pub;
protected:
 int _pro;
private:
 int _pri;
};
int main()
{
 base b(10,20,30);//构造函数
 b.dis();//函数调用
 Derive d;//构造函数，现在初始化列表中构造父类，再构造子类
 cout << endl << "***************************记住这个d.pub=" << d.pub << "*********************"<< endl << endl;
 d.dis();//函数调用
 b = d;//赋值运算符重载，这里面进行了一个切片动作,也记住这个切片
 b.operator=(d);//与上一行等价
 //d.operator=((Derive*)b);//父类不能给子类赋值·error:不存在从base到Derive*的适当转换函数
               //也就是说如果派生类包含了转换构造函数，即对基类对象转换为派生类对象进行了定义，则可以将基类对象赋给派生对象。
 //d = (Derive*)b;与上一行等价
 b.dis();//重载后再次函数调用
 system("pause");
 return 0;
}

 

运行结果：

 

大家可能会对这个 最后重载之后再次函数调用 b.dis();这块有所疑问，为什么全局都没有输出1，2，3  最后却来个这。？

分析：
 首先看赋值运算符重载函数  base& operator= (const base& b1)
  注意这里其实是有两个参数：隐含的this指针(10,20,30)和b1(1,2,3)
  注意这里的形参b1是base类的，而实参d则是Derive类的，说明发生了切片。
  所以原先这个d里面包含的是他本身的成员(4,5,6)和父类的(1,2,3）
 切记不是父类对象的(10,20,30)，在那里我特意输出pub的值就是让你知道，这里是父类的(1,2,3)....
  进行切片之后呢就把除父类之外的子类部分全部切掉，只保留下来父类的成员(1,2,3)...
 所以咯，这里就输出了(1,2,3)而不是容易误导我们的(10,20,30)

 

好了，上面大概就是我对这四个默认成员函数的一些了解，哪有不对就指出来哦。。