C++之再谈构造函数
2018-01-28 本文已影响0人
bluewind1230
#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;
}
输出见下:
image.png
小结:
在定义时候,如果一个类的数据成员是另外一个类的对象的时候,在调用构造函数创建对象的时候,对作为数据成员的对象先要自动调用数据成员其自身的构造函数
- 做一个小变化,将定义时的顺序做一个调整:
#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;
}
image.png
小结:
成员变量初始化取决于在类中的定义顺序.
构造函数与析构函数之间的几个对比:
析构函数的特点:
- 无返回类型(析构与构造两者都没有)
- 函数名与类名一样,析构函数前面有逻辑反运算符("~"),构造函数没有
- 无参数（构造函数可以有参数,构造函数有了参数就不是默认构造了）
- 不能随意调用(析构函数是可以调用的,只不过不能随意调用)
- 不能重载,只能有一个析构函数(而构造函数可以重载)
- 析构函数可以是虚函数(而构造函数不可以)
// C++复习.cpp : 定义控制台应用程序的入口点。
//
#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;
}
输出:
image.png
由上图可以看出:
析构函数以为调用构造函数相反的顺序 被调用！
再看一个例子：
转换构造:
// 转换构造.cpp : 定义控制台应用程序的入口点。
//
#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 是隐式调用
运行结果:
image.png
执行到fun(5)这一步的时候:会在类里面寻找这样一个构造函数:它里面有没有一个单个参数的构造函数,如果有,那就是转换构造,将5转换成一个对象类型,如果没有,就会报错!
小结:
- 有几个对象就至少执行几次析构
- 转换构造函数以及拷贝构造的调用顺序：对象objA->对象objB->对象objC(调用拷贝构造)->执行fun函数时候所创建的临时对象
(这一过程中实际上转换构造和拷贝构造代替了默认构造的功能,每创建一个对象都会调用一个构造函数(默认构造,转换构造,拷贝构造等皆可)) - 执行fun函数时候所创建的临时对象->对象objC->对象objB->对象objA
转换构造的一个注意点:
一般而言其调用时机为:
只有一个参数,参数类型不是本类类型
以上面的例子为例:
1.CNumber objA(12);
2. CNumber objB = 34;
3.fun(5);
void fun(const CNumber& obj) {
printf("执行fun函数了\n");
}
注意点(禁止调用的时机):
在单个参数的构造函数之前加上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.拷贝构造函数只有一个形参数,该参数是该类的对象的引用,
(注意:这里为什么是引用类型？？？)
如果不是引用类型,即为CNumber C，此时又会调用构造函数,如此不同的反复循环下去!!!!所以这里一定要加一个引用符号！！！！！(后面有很多地方涉及到类类型的都是这个原因!!!!!!!)
- 对象需要通过另外一个对象进行初始化；
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);*/
}
- 对象以值传递的方式传入函数参数
// 拷贝构造1.cpp : 定义控制台应用程序的入口点。
//
#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)
image.png
- 函数的返回值为对象时,系统会自动调用拷贝构造函数对返回对象值创建一个临时对象,然后再将这个临时对象值赋给接收返回值的对象
// 拷贝构造2.cpp : 定义控制台应用程序的入口点。
//
#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);
- (3).在函数执行到最后先析构temp局部变量。
-
(4).等g_Fun()执行完后再析构掉XXXX对象。(析构顺序有待考证,先建立了哪个对象,后建立了哪个对象??)
image.png
构造函数必须要初始化的几种情况:
a)没有默认构造函数的类对象;
b)const类型变量
c)引用类型变量
情况a)的实例(必须传入参数才能构造的对象)
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 //初始化列表的顺序:按照成员变量定义的顺序进行初始化
}
