默认成员函数
在继承关系里面, 在派生类中如果没有显示定义下列六个成员函数, 编译系统则会默认合成这六个默认的成员函数。
在继承关系里面, 在派生类中如果没有显示定义下列六个成员函数, 编译系统则会默认合成这六个默认的成员函数。
上图:
这篇文章会详细介绍
构造函数,析构函数,拷贝构造函数和赋值运算符的重载。
因为另外两个在我们这个阶段基本上不用到,所以只要大概知道有这么个东西就行(说白了就是我也不会。。。)
下面我们先讲:
因为另外两个在我们这个阶段基本上不用到,所以只要大概知道有这么个东西就行(说白了就是我也不会。。。)
下面我们先讲:
构造函数和析构函数
构造函数和析构函数概念的东西就不用过多解释了吧,应该都懂。。直接上代码
代码块:
#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.多继承同理,只是两个父类对象,按照先声明的先构造。
拷贝构造函数:(单参)
注意区分:构造函数是创建新的对象并初始化。
拷贝构造函数是
利用已有对象来初始化这个新对象。
调用拷贝构造函数的三种情况:
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)
首先看赋值运算符重载函数 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)
好了,上面大概就是我对这四个默认成员函数的一些了解,哪有不对就指出来哦。。