C++类之构造函数

Time.h头文件

#ifndef _MYTIME_	
#define _MYTIME_

class Time
{
public:
	int Hour;
	int Minute;
	int Second;

	//成员函数
	//void initTime(int tmphour, int tmpmin, int tmpsec);

public:
	//构造函数
	explicit Time(int tmphour, int tmpmin, int tmpsec); //explicit 显示的, 而非隐式的 不能Time() = xx;
	Time(int tmphour, int tmpmin);
	Time(int tmphour);
	explicit Time();
	//拷贝构造函数
	Time(const Time &tmtptime, int a = 56); //最好在开头加const 第一个参数是所属类 地址的引用引用
	//拷贝构造函数的作用:会在一定的时机,被系统自动调用
	//(1) 建议拷贝构造函数第一个参数总是带const
	//(2) 拷贝构造函数一般不带explicit

	//重载的赋值运算符
	Time& operator = (const Time&);//重载的赋值运算符

	~Time();//析构函数


	

	//成员函数加const
public:
	void addhour(int tmphour) const;
	Time& add_hour(int tmphour);

private:
	int Millsecond; //毫秒

	void initMillTime(int mls);
};

//public:
	

#endif

Time.cpp

//#include "stdafx.h"

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

//成员 iniTime()的实现
//两个冒号叫作用域运算符，表示iniTime属于Time 的Class

//void Time:: initTime(int tmphour, int tmpmin, int tmpsec)
//{
//	Hour = tmphour;
//	Minute = tmpmin;
//	Second = tmpsec;
//}

void Time::initMillTime(int mls)
{
	Millsecond = mls; //成员函数可以访问成员变量,无论是否私有
}

/// <summary>
/// 构造函数初始化 带两个参数的构造函数
/// </summary>
/// <param name="tmphour"></param>
/// <param name="tmpmin"></param>
/// <param name="tmpsec"></param>
Time::Time(int tmphour, int tmpmin, int tmpsec) 
	:Hour(tmphour), Minute(tmpmin), Second(tmpsec), Millsecond(0) //Millsecond(0) //构造函数初始化列表 效率高
{
	//Hour = tmphour;
	//Minute = tmpmin;
	//Second = tmpsec;
	//initMillTime(0);

	std::cout << "调用了构造函数Time::Time(int tmphour, int tmpmin, int tmpsec)" << std::endl;
}

Time::Time()
{
	Hour = 12;
	Minute = 50;
	Second = 52;
	initMillTime(50);

	std::cout << "调用了构造函数Time::Time()" << std::endl;
}

//void Time::addhour(int tmphour) const
//{
//	//Minute = tmphour; //报错 必须是常量
//}

Time& Time:: add_hour(int tmphour)
{
	Hour += tmphour;
	return *this; //
}

Time::Time(const Time &tmptime, int a)
{
	std::cout << "调用了Time::Time(const Time& tmptime, int a)拷贝构造函数" << std::endl;
}

//赋值运算符的重载
Time& Time::operator = (const Time&)//重载的赋值运算符
{
	std::cout<<"调用了Time& Time::operator = (const Time&) 赋值运算符重载" << std::endl;
	return *this;
}
Time::~Time()
{
	std::cout << "调用了析构函数,并不在析构函数里销毁" << std::endl;

}

主程序

#include "head2.h"
#include "student.h"
#include "Time.h"
#include <cstdio>//stdio.h
#include <iostream>

using namespace std;

//class student
//{
//public:
//	int number;
//	char name[100];
//
//};





int main()
{
	//如果访问类成员，就使用对象名.成员名 访问
	//如果指向这个对象的指针，就用 指针名->成员名 来访问成员。
	//struct A{...}等价于class A{public: ......}

	//student someone; //定义对象
	//someone.number = 1000; //访问成员
	//student* psomeone = &someone;
	//psomeone->number = 1005;

	//cout << someone.number << endl;

	/// <summary>
	/// 三，成员函数
	/// </summary>
	/// <returns></returns>
	
	//Time myTime;
	//myTime.initTime(11, 14, 5);
	//cout << myTime.Hour << endl; //11
	//cout << myTime.Minute << endl; //14
	//cout << myTime.Second << endl; //5
	//return 0;

	/// <summary>
	/// 四，对象的拷贝
	/// </summary>
	/// <returns></returns>
	//Time myTime;
	//myTime.Hour = 12;
	//myTime.Minute = 12;
	//myTime.Second = 12;

	//Time myTime2 = myTime;
	//Time myTime3(myTime);
	//Time myTime4{ myTime };
	//Time myTime5 = { myTime };

	//多个构造函数
	//Time myTime10 = Time();

	//Time myTime12;
	//Time myTime13 = Time{};
	//Time myTime114{};
	//Time myTime15 = {};

	//Time mytime;
	//mytime.add_hour(3); 
	//-		&mytime	0x000000e43b1ef598 {Hour=12 Minute=50 Second=52 ...}	Time *
	// -		this	0x000000e43b1ef598 {Hour=15 Minute=50 Second=52 ...}	Time *
	// this 指向mytime


	//六, 拷贝构造函数
	//Time myTime;
	//Time myTime2 = myTime;
	//Time myTime3(myTime);
	//Time myTime4{ myTime };
	//Time myTime5 = { myTime };
	//Time myTime6;
	//myTime6 = myTime; // 调用了Time& Time::operator = (const Time&) 赋值运算符重载

		//调用了构造函数Time::Time()
		//调用了Time::Time(const Time & tmptime, int a)拷贝构造函数
		//调用了Time::Time(const Time & tmptime, int a)拷贝构造函数
		//调用了Time::Time(const Time & tmptime, int a)拷贝构造函数
		//调用了Time::Time(const Time & tmptime, int a)拷贝构造函数
		//调用了构造函数Time::Time()
		//调用了Time& Time::operator = (const Time&) 赋值运算符重载
		//调用了析构函数, 并不在析构函数里销毁
		//调用了析构函数, 并不在析构函数里销毁
		//调用了析构函数, 并不在析构函数里销毁
		//调用了析构函数, 并不在析构函数里销毁
		//调用了析构函数, 并不在析构函数里销毁
		//调用了析构函数, 并不在析构函数里销毁

	//七, new 对象 和delete对象

	Time* pmytime5 = new Time; //调用不带参数的构造函数
	Time* pmytime6 = new Time();
	 
	delete pmytime5; //释放内存 并调用析构函数
	delete pmytime6;

	return 0;
}