构造函数与析构函数（3）

1）构造函数初始化列表

2）对象成员及其初始化

3）const成员、引用成员初始化

1）构造函数初始化列表

推荐在构造函数初始化列表中进行初始化。

构造函数的执行分为两个阶段

        初始化段

普通计算段

#ifndef _CLOCK_H_
#define _CLOCK_H_

class Clock
{
public:
	Clock(int hour = 0,int minute = 0, int second = 0);

	~Clock();
	void Display();
	void Init(int hour, int minute, int second);
	void Update();

	int GetHour();
	int GetMinute();
	int GetSecond();

	void SetHour(int hour);
	void SetMinute(int minute);
	void SetSecond(int second);


private:
	int hour_;
	int minute_;
	int second_;
};


#endif // !_CLOCK_H_

#include "Clock.h"
#include <iostream>

using namespace std;


void Clock::Display()
{
	cout << hour_ << ":" << minute_ << ":" << second_ << endl;

}

//推荐使用初始化列表对对象进行初始化，在构造函数内的是赋值操作，类似于int a;在赋值给a  = 10;
Clock::Clock(int hour, int minute, int second):hour_(hour),minute_(minute),second_(second)
{
	/*hour_ = hour;
	minute_ = minute;
	second_ = second;
	*/
	cout << "Clock::Clock" << endl;
}

/*void Clock::Init(int hour, int minute, int second)
{
	hour_ = hour;
	minute_ = minute;
	second_ = second;

}*/

Clock::~Clock()
{
	cout << "Clock::~Clock" << endl;
}

void Clock::Update()
{
	second_++;
	if (second_ == 60)
	{
		minute_++;
		second_ = 0;

	}
	if (minute_ == 60)
	{
		hour_++;
		minute_ = 0;
	}
	if (hour_ == 24)
	{
		hour_ = 0;
	}
}

int Clock::GetHour()
{
	return hour_;

}

int Clock::GetMinute()
{
	return minute_;
}

int Clock::GetSecond()
{
	return second_;
}

void Clock::SetHour(int hour)
{
	hour_ = hour;

}
void Clock::SetMinute(int minute)
{
	minute_ = minute;
}

void Clock::SetSecond(int second)
{
	second_ = second;
}

#include "Clock.h"

int main(void)
{
	Clock c(10,10,10);
	c.Display();

	return 0;
}

2）对象成员及其初始化

#include <iostream>

using namespace std;

//一般来讲将类的声明放在.h,类的实现放在.cpp这里为了方便实现，将在这里创建一个类。
class Object
{
public:
	Object(int num):num_(num)
	{
		cout << "Object..." << num_ << endl;

	}
	~Object()
	{
		cout << "~Oblect..." <<  num_<< endl;

	}

private:
	int num_;

};

class Container
{
public:
	Container(int obj1=0,int obj2=0):obj1_(obj1),obj2_(obj2)
	{
		cout << "Container..." << endl;

	}
	~Container()
	{
		cout << "~Container..." << endl;
	}
private:
	Object obj1_;
	Object obj2_;

};
int main(void)
{
	Container c(10,20); //实例化c,初始化值10，20

	return 0;
}

/*
输出：
Object...10     初始化obj1_,调用obj1_构造函数
Object...20		初始化obj2_,调用obj2_构造函数
Container...	调用c构造函数
~Container...	析构c
~Oblect...20	析构obj2_
~Oblect...10	析构obj1_
*/

3）const成员、引用成员初始化

#include <iostream>

using namespace std;

//一般来讲将类的声明放在.h,类的实现放在.cpp这里为了方便实现，将在这里创建一个类。
class Object
{
public:
	//要使常量对所有的对象有用
	enum E_TYPE
	{
		TYPE_A = 100,
		TYPE_B  = 200
	};
public:
	//const成员的初始化引用成员的初始化只能在构造函数初始化列表中进行
	//引用成员的初始化只能在构造函数初始化列表中进行
	//对象成员（对象所对应的类没有默认构造函数）的初始化，也只能在构造函数初始化列表中进行
	Object(int num = 0) :num_(num),kNum_(num),refNum_(num_) 
	{
		//kNum_ = 100;这里是赋值并不是初始化
		//refNum_ = num;
		cout << "Object..." << num_ << endl;

	}
	~Object()
	{
		cout << "~Oblect..." << num_ << endl;

	}
	void DisplayKNum()
	{
		cout << "kNum=" << kNum_ << endl;
	}
private:
	int num_;
	const int kNum_;
	int& refNum_;


};


int main(void)
{
	Object obj1(10);
	Object obj2(20);
	obj1.DisplayKNum();//输出：kNum=10  这里尽管定义的是const,但是对于不同的类，kNum_不同,要是对所有的类都是同一个常量，要用到枚举
	obj2.DisplayKNum();//输出：kNum = 20

	cout << obj1.TYPE_A << endl;
	cout << obj2.TYPE_B << endl;

	return 0;
}
/*

输出：
Object...10
Object...20
kNum=10
kNum=20
100
200
~Oblect...20
~Oblect...10
*/