构造函数
构造函数的意义
不需要手动调用构造函数来初始化对象;编译器会为我们生成调用构造函数代码
必须要初始化成员变量情况
1.没有默认构造函数的类对象
2.const类型
3.引用类类型
情况1的实例:
class CBase
{
public:
CBase(int a) {};//不是默认构造函数，默认构造函数没有形参
~CBase();
};
class CHello {
public :
CHello() :Cbase(1) {};//没有默认构造函数的类对象必须初始化在初始化列表里面
private:
int m_nNuma;
CBase cbase; //没有默认构造函数的类对象
};注:初始化列表在冒号后面
:初始化列表的顺序:按照成员变量定义的顺序进行初始化:
Class CLocation{
Public:
CLocation(int nX, int nY):m_X(nX),m_Y(nY)// 初始化列表在冒号后面
{}
Private:
int m_X , m_Y //初始化列表的顺序:按照成员变量定义的顺序进行初始化
}调用构造函数的顺序
#include "stdafx.h"
#include <iostream>
using namespace std;
class Cstudent
{
public:
Cstudent() { cout << "student"<<endl; };
};
class Cteacher
{
public:
Cteacher() { cout << "cteacher"<<endl; };
};
class Ctutor
{
public:
Ctutor() { cout << "Ctutor"<<endl; };
protected:
Cstudent m_objstudent;//另外一个类的数据
Cteacher m_objteacher;//另外一个类的数据
};
int main()
{
Ctutor tutor;
return 0;
}
输出见下:
做一个小变化,将定义时的顺序做一个调整:
#include "stdafx.h"
#include <iostream>
using namespace std;
class Cstudent
{
public:
Cstudent() { cout << "student"<<endl; };
};
class Cteacher
{
public:
Cteacher() { cout << "cteacher"<<endl; };
};
class Ctutor
{
public:
Ctutor() { cout << "Ctutor"<<endl; };
protected:
Cteacher m_objteacher;//这里与上面这个例子有所不同
Cstudent m_objstudent;
};
int main()
{
Ctutor tutor;
return 0;
}
小结:
1.在定义时候,如果一个类的数据成员是另外一个类的对象的时候,在调用构造函数创建对象的时候,对作为数据成员的对象先要自动调用数据成员其自身的构造函数;
2.成员变量初始化取决于在类中的定义顺序;
3.总的顺序:先调用数据成员自身的构造(调用数据成员自身的构造的顺序则按照在类中的定义顺序),然后再调用本类构造;
有参与无参构造的对比
- 如果有一个有参构造函数,但又没有赋值初始化,必须再写一个无参构造函数,因为此时默认无参构造没了;
#include <iostream>
using namespace std;
class Dog
{
public:
string name;
// 无参构造函数
Dog()
{
cout << "Dog's constructor!" << endl;
}
// 有参构造函数
Dog(string Name)
{
name = Name;
cout << "Dog's constructor with name!" << endl;
}
void run()
{
cout << name << " is running..." << endl;
}
};
int main()
{
Dog dog1;
dog1.name = "Wang Cai";
dog1.run();
Dog dog2("Xiao Bai");
dog2.run();
return 0;
}运行结果:
Dog’s constructor!
Wang Cai is running...
Dog’s constructor with name!
Xiao Bai is running
从运行结果可以看出，构造函数是在生成对象时被调用的，并且不需要显示调用。构造函数的特征:
1.函数名必须和类名一致
2.无返回值
3.可以有参数
4.不能为虚函数
5.可以类外定义(类名::)
默认构造函数的特征:
1.无形参
2.调用时机:构造对象的时候,如果没有往构造函数中传参,就默认调用该形式的构造函数,(注意:不要在构造函数中定义对象)
析构函数
析构函数特点
1.无返回类型(析构与构造两者都没有)
2.函数名与类名一样,析构函数前面有逻辑反运算符(“~”),构造函数没有
3.无参数（构造函数可以有参数,构造函数有了参数就不是默认构造了）
4.不能随意调用(析构函数是可以调用的,只不过不能随意调用);
5.不能重载,只能有一个析构函数(而构造函数可以重载)
6.析构函数可以是虚函数(而构造函数不可以)
析构函数调用顺序
#include "stdafx.h"
#include <iostream>
using namespace std;
class Cstudent
{
public:
Cstudent() { cout << "student"<<endl; };
~Cstudent() { cout << "student 析构" << endl; };
};
class Cteacher
{
public:
Cteacher() { cout << "cteacher"<<endl; };
~Cteacher() { cout << "cteacher 析构" << endl; };
};
class Ctutor
{
public:
Ctutor() { cout << "Ctutor"<<endl; };
~Ctutor() { cout << "Ctutor 析构" << endl; };
protected:
Cteacher m_objteacher;
Cstudent m_objstudent;
};
int main()
{
Ctutor tutor;
return 0;
}
小结:
析构函数以为调用构造函数相反的顺序 被调用
具有继承关系的类之间的构造和析构调用顺序
#include "stdafx.h"
#include <ostream>
#include <iostream>
using namespace std;
class cclassA {
public:
cclassA() {
cout << "调用父类的构造了" << endl;
}
~cclassA() {
cout << "调用父类的析构了" << endl;
}
};
class cclassB :public cclassA
{
public:
cclassB() {
cout << "调用子类的构造了" << endl;
}
~cclassB() {
cout << "调用子类的析构了" << endl;
}
protected:
private:
};
int main()
{
cclassB objB;
return 0;
}
理解:
创建一个对象,就是要先创建一段空间,所以要先为objB开辟一段空间,而cclassB是来自于cclass A的空间的,所以要先调用cclassA的构造函数
拷贝构造
特征:
1.拷贝构造函数名与类名同名,没有返回类型;
2.拷贝构造函数只有一个形参数,该参数是该类的对象的引用;
这里why为引用类型？
如果不是引用类型,即为CNumber C，此时又会调用构造函数,如此不同的反复循环下去!!!!所以这里一定要加一个引用符号！！！！！(后面有很多地方涉及到类类型的都是这个原因!!!!!!!)
举个例子来理解:
CCounter& operator=(CCounter &obj) { //1th
m_nValue = obj.m_nValue;
return *this;
}1.如果返回类型为类类型,即为CCounter,则在执行return这一句话的时候,会再次调用拷贝构造
2.从调用拷贝构造的时机来理解的话,实际上可以这么理解:
CCounter XXX(临时对象)= *this;,这样的话就会调用拷贝构造,因为XXX和*this指的是两个对象(两个对象的话,肯定需要再次开辟内存空间,就会再次调用拷贝构造),引用传递的就是它自己,所以不存在有两个对象的情况
拷贝构造调用时机
1.对象以值传递的方式传入函数参数
#include "stdafx.h"
#include <ostream>
#include <iostream>
using namespace std;
class CExample
{
private:
int a;
public:
//构造函数
CExample(int b) //3th
{
a = b;
cout << "creat:调用构造 " << endl;
}
//拷贝构造
CExample(const CExample& C) //4th
{
a = C.a;
cout << "copy调用拷贝构造" << endl;
}
//析构函数 //5th
~CExample()
{
cout << "delete: 进行析构" << endl;
}
void Show()
{
cout << a << endl;
}
};
//全局函数，传入的是对象 !!!!!
void g_Fun(CExample C) //6th
{
cout << "test,执行全局函数了" << endl;
}
int main()
{
CExample test(1); //1th
//传入对象
g_Fun(test); //2th
getchar(); //7th
return 0;
}
//执行CExample test(1);时候，调用构造函数；然后调用g_Fun(test);调用g_Fun()时，
//会产生以下几个重要步骤：
//(1)test对象传入形参时，会先会产生一个临时变量，就叫 C 吧。
//(2)然后调用拷贝构造函数把test的值给C。(拷贝构造函数就是把一个对象的值拷给另一个), 整个这两个步骤有点像：CExample C(test);
//(3)等g_Fun()执行完后, 析构掉 C 对象。
//1th(定义并初始化)->3th(调用构造函数)->1th->2th(调用g_Fun函数)->4th(调用拷贝构造)->2th->6th(执行函数体)->5th(离开函数体就执行析构函数)->离开函数之后再调用一次析构(析构的对象应该是 CExample test)
下面的总结里面也说了:有几个对象就析构几次!!!
过程:1th(定义并初始化)->3th(调用构造函数)->1th->2th(调用g_Fun函数)->4th(调用拷贝构造)->2th->6th(执行函数体)->5th(离开函数体就执行析构函数)->再调用一次析构(析构的对象应该是 CExample test)
2.对象需要通过另外一个对象进行初始化
1). CExample A(100);
2). CExample B = A;
3).CExample B(A);
后两句都会调用拷贝构造函数。第一句调用非默认构造!
CNumber objC = objA；
CNumber(CNumber&C) {
printf("拷贝构造\n");
/*printf("%d\n", m_nNum);*/
}3.函数的返回值为对象时,系统会自动调用拷贝构造函数对返回对象值创建一个临时对象,然后再将这个临时对象值赋给接收返回值的对象
#include "stdafx.h"
#include <ostream>
#include <iostream>
using namespace std;
class CExample
{
private:
int a;
public:
//构造函数
CExample(int b) //3th
{
a = b;
cout << "调用构造"<< endl;
}
//拷贝构造
CExample(const CExample& C) //4th
{
a = C.a;
cout << "copy调用拷贝" << endl;
/*cout << a << endl;
cout << C.a << endl;*/ //C.a=0
}
~CExample() //5th
{
cout << "delete:调用析构 " << a << endl;
/*cout << "delete: " <<&C.a << endl;*/
}
void Show()
{
cout << a << endl;
}
};
//全局函数
CExample g_Fun() //2th,返回值为类 类型
{
CExample temp(0); //temp是一个对象,创建一个对象并初始化,
return temp;
}
int main()
{
g_Fun(); //1th
return 0;
}
当g_Fun()函数执行到return时，会产生以下几个重要步骤：
(1).先会产生一个临时变量，就叫XXXX吧。
(2).然后调用拷贝构造函数把temp的值给XXXX。整个这两个步骤有点像：CExample XXXX(temp)//CExample XXXX=temp
(3).在函数执行到最后先析构temp局部变量。
(4).等g_Fun()执行完后再析构掉XXXX对象。(析构顺序有待考证,先建立了哪个对象,后建立了哪个对象??)
转换构造
转换构造函数特征
1.只有一个参数
2.参数的类型不是本类类型
3.explicit:用于禁止隐式转换
作用:将一个其他类型的数据转换成一个类的对象
调用时机
只有一个参数,参数类型不是本类类型
1.CNumber objA(12);
2. CNumber objB = 34;
3.fun(5);
void fun(const CNumber& obj) {
printf("执行fun函数了\n");
}#include "stdafx.h"
class CNumber {
public:
CNumber() { //1th
printf("默认构造\n");
}
CNumber(int nNum) { //2th
m_nNum = nNum;
printf("转换构造\n");
printf("%d\n", m_nNum);
}
CNumber(CNumber&C) { //3th
/* m_nNum = nNum;*/
printf("拷贝构造\n");
/*printf("%d\n", m_nNum);*/
}
~CNumber() { // 4th
printf("析构\n");
}
private:
int m_nNum;
};
void fun(const CNumber& obj) { //9th obj是调用函数fun时候创建匿名对象的别名
printf("执行fun函数了\n");
}
void fun1(const CNumber& obj) { // 注意:这里必须要加const,不然会报错,也要加&(引用符号)
printf("执行fun函数了\n");
}
int main()
{
CNumber objA(12); // 5th (这一步执行转换构造,不执行默认构造,因为它这里有一个参数,转换构造代替了默认构造的作用)
CNumber objB = 34; //6th(这一步也执行转换构造) 执行这一步的时候它会找到上面的转换构造，
CNumber objC = objA; //再加上这一句就会调用拷贝构造
//同时生成对象objB,没有创建临时对象
fun(5); //8th
/*fun1(3);*/
return 0; //7th
}
//5th->2th(转换构造)->5th->6th->2th(转换构造)->6th->8th->2th(转换构造)
//->8th->9th(执行全局函数)->8th->4th(析构)->7th->4th(析构)->7th->
//4th(析构)->7th->结束
//结论：转换构造函数的调用顺序：对象objA->对象objB->执行fun函数时候所创建的临时对象
//三次析构的顺序：执行fun函数时候所创建的临时对象->对象objB->对象objA
//一般情况下，有几个对象就至少执行几次析构
//5th 是显式调用
//6th, 8th 是隐式调用
执行到fun(5)这一步的时候:会在类里面寻找这样一个构造函数:它里面有没有一个单个参数的构造函数,如果有,那就是转换构造,将5转换成一个对象类型,如果没有,就会报错!
注意点(禁止调用的时机):
在单个参数的构造函数之前加上explicit关键字,就会阻止转换构造,同时也阻止l了在定义了对象时候,使用等号初始化对象
#include "stdafx.h"
class MyClass
{
public:
explicit MyClass(int num) {
m_nNum = num;
};
~MyClass();
private:
int m_nNum;
};
MyClass::~MyClass()
{
}
int main()
{
MyClass objA(12);
MyClass objB = 34;//此处会编译不通过,报错:无法从int转换为Myclass
return 0;
}
小结
1.有几个对象就至少执行几次析构
2.转换构造函数以及拷贝构造的调用顺序：对象objA->对象objB->对象objC(调用拷贝构造)->执行fun函数时候所创建的临时对象
(这一过程中实际上转换构造和拷贝构造代替了默认构造的功能,每创建一个对象都会调用一个构造函数(默认构造,转换构造,拷贝构造等皆可))
3.执行fun函数时候所创建的临时对象->对象objC->对象objB->对象objA
222
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
