7.C++入门：类和对象|日期类的实现|取地址运算符重载|const成员函数|初始化列表|类型转换

ChoSeitaku

699人浏览 · 2025-12-28 22:20:17

ChoSeitaku · 2025-12-28 22:20:17 发布

⽇期类实现

#pragma once  
#include<iostream>  
using namespace std;  

#include<assert.h>  

class Date  
{  
	// 友元函数声明  
	friend ostream& operator<<(ostream& out, const Date& d);  
	friend istream& operator>>(istream& in, Date& d);  
	
public:  
	Date(int year = 1900, int month = 1, int day = 1);  
	void Print() const;  
	// 直接定义类⾥⾯，他默认是inline  
	// 频繁调⽤
	int GetMonthDay(int year, int month)  
	{  
		assert(month > 0 && month < 13);  
		static int monthDayArray[13] = { -1, 31, 28, 31, 30, 31, 30,  
		31, 31, 30, 31, 30, 31 };  
		// 365天 5h +  
		if (month == 2 && (year % 4 == 0 && year % 100 != 0) || (year  
		% 400 == 0))  
		{  
			return 29;  
		} 
		else  
		{  
			return monthDayArray[month];  
		}  
	} 
	
	bool CheckDate();  
	
	bool operator<(const Date& d) const;  
	bool operator<=(const Date& d) const;  
	bool operator>(const Date& d) const;  
	bool operator>=(const Date& d) const;  
	bool operator==(const Date& d) const;  
	bool operator!=(const Date& d) const;  
	
	// d1 += 天数  
	Date& operator+=(int day);  
	Date operator+(int day) const;  
	
	// d1 -= 天数  
	Date& operator-=(int day);  
	Date operator-(int day) const;  
	
	// d1 - d2  
	int operator-(const Date& d) const;  
	
	// ++d1 -> d1.operator++()  
	Date& operator++();  
	
	// d1++ -> d1.operator++(0)  
	// 为了区分，构成重载，给后置++，强⾏增加了⼀个int形参  
	// 这⾥不需要写形参名，因为接收值是多少不重要，也不需要⽤  
	// 这个参数仅仅是为了跟前置++构成重载区分  
	Date operator++(int);
	Date& operator--();  
	Date operator--(int);  
	
	// 流插⼊  
	// 不建议，因为Date* this占据了⼀个参数位置，使⽤d<<cout不符合习惯  
	//void operator<<(ostream& out); 
	 
private:  
	int _year;  
	int _month;  
	int _day;  
};  

// 重载  
ostream& operator<<(ostream& out, const Date& d);  
istream& operator>>(istream& in, Date& d);

// Date.cpp  
#include"Date.h"  

bool Date::CheckDate()  
{  
	if (_month < 1 || _month > 12  
	|| _day < 1 || _day > GetMonthDay(_year, _month))  
	{  
		return false;  
	} 
	else  
	{  
		return true;  
	}  
} 

Date::Date(int year, int month, int day)  
{  
	_year = year;  
	_month = month;  
	_day = day;  
	if (!CheckDate())  
	{  
		cout << "⽇期⾮法" << endl;  
	}  
} 

void Date::Print() const  
{
	cout << _year << "-" << _month << "-" << _day << endl;  
} 

// d1 < d2  
bool Date::operator<(const Date& d) const  
{  
	if (_year < d._year)  
	{  
		return true;  
	} 
	else if (_year == d._year)  
	{  
		if (_month < d._month)  
		{  
			return true;  
		} 
		else if (_month == d._month)  
		{  
			return _day < d._day;  
		}  
	} 
	return false;  
} 

// d1 <= d2  
bool Date::operator<=(const Date& d) const  
{  
	return *this < d || *this == d;  
} 

bool Date::operator>(const Date& d) const  
{  
	return !(*this <= d);  
} 

bool Date::operator>=(const Date& d) const  
{  
	return !(*this < d);  
} 

bool Date::operator==(const Date& d) const  
{  
	return _year == d._year  
	&& _month == d._month  
	&& _day == d._day;  
}

bool Date::operator!=(const Date& d) const  
{  
	return !(*this == d);  
} 

// d1 += 50  
// d1 += -50  
Date& Date::operator+=(int day)  
{  
	if (day < 0)  
	{  
		return *this -= -day;  
	} 
	_day += day;  
	while (_day > GetMonthDay(_year, _month))  
	{  
		_day -= GetMonthDay(_year, _month);  
		++_month;  
		if (_month == 13)  
		{  
			++_year;  
			_month = 1;  
		}  
	} 
	return *this;  
} 

Date Date::operator+(int day) const  
{  
	Date tmp = *this;  
	tmp += day;  
	return tmp;  
} 

// d1 -= 100  
Date& Date::operator-=(int day)  
{  
	if (day < 0)  
	{  
		return *this += -day;  
	}
	_day -= day;  
	while (_day <= 0)  
	{  
		--_month;  
		if (_month == 0)  
		{  
			_month = 12;  
			_year--;  
		} 
		// 借上⼀个⽉的天数  
		_day += GetMonthDay(_year, _month);  
	} 
	
	return *this;  
} 

Date Date::operator-(int day) const  
{  
	Date tmp = *this;  
	tmp -= day;  
	
	return tmp;  
} 
//++d1  
Date& Date::operator++()  
{  
	*this += 1;  
	
	return *this;  
} 

// d1++  
Date Date::operator++(int)  
{  
	Date tmp(*this);  
	*this += 1;  
	
	return tmp;  
} 

Date& Date::operator--()  
{  
	*this -= 1;  
	
	return *this;  
}

Date Date::operator--(int)  
{  
	Date tmp = *this;  
	*this -= 1;  
	
	return tmp;  
} 

// d1 - d2  
int Date::operator-(const Date& d) const  
{  
	Date max = *this;  
	Date min = d;  
	int flag = 1;  
	if (*this < d)  
	{  
		max = d;  
		min = *this;  
		flag = -1;  
	} 
	
	int n = 0;  
	while (min != max)  
	{  
		++min;  
		++n;  
	} 
	
	return n * flag;  
} 

ostream& operator<<(ostream& out, const Date& d)  
{  
	out << d._year << "年" << d._month << "⽉" << d._day << "⽇" << endl;  
	
	return out;  
} 

istream& operator>>(istream& in, Date& d)  
{  
	cout << "请依次输⼊年⽉⽇:>";  
	in >> d._year >> d._month >> d._day;  
	if (!d.CheckDate())  
	{  
		cout << "⽇期⾮法" << endl;  
	}
	
	return in;  
}

// Test.cpp  
#include"Date.h"  
void TestDate1()  
{  
	// 这⾥需要测试⼀下⼤的数据+和-  
	Date d1(2024, 4, 14);  
	Date d2 = d1 + 30000;  
	d1.Print();  
	d2.Print();  
	
	Date d3(2024, 4, 14);  
	Date d4 = d3 - 5000;  
	d3.Print();  
	d4.Print();  
	
	Date d5(2024, 4, 14);  
	d5 += -5000;  
	d5.Print();  
} 

void TestDate2()  
{  
	Date d1(2024, 4, 14);  
	Date d2 = ++d1;  
	d1.Print();  
	d2.Print();  
	
	Date d3 = d1++;  
	d1.Print();  
	d3.Print();  
	
	/*d1.operator++(1);  
	d1.operator++(100);  
	d1.operator++(0);  
	d1.Print();*/  
} 

void TestDate3()  
{  
	Date d1(2024, 4, 14);  
	Date d2(2034, 4, 14);  
	
	int n = d1 - d2;
	cout << n << endl;  
	
	n = d2 - d1;  
} 

void TestDate4()  
{  
	Date d1(2024, 4, 14);  
	Date d2 = d1 + 30000;  
	
	// operator<<(cout, d1)  
	cout << d1;  
	cout << d2;  
	
	cin >> d1 >> d2;  
	cout << d1 << d2;  
} 

void TestDate5()  
{  
	const Date d1(2024, 4, 14);  
	d1.Print();  
	
	//d1 += 100;  
	d1 + 100;  
	
	Date d2(2024, 4, 25);  
	d2.Print();  
	
	d2 += 100;  
	
	d1 < d2;  
	d2 < d1;  
} 

int main()  
{  

	return 0;  
}

取地址运算符重载

const成员函数

将const修饰的成员函数称之为const成员函数，const修饰成员函数放到成员函数参数列表的后⾯。
const实际修饰该成员函数隐含的this指针，表明在该成员函数中不能对类的任何成员进⾏修改。
const修饰Date类的Print成员函数，Print隐含的this指针由 Date* const this 变为
const Date* const this
const对象和非const对象都可以调用const成员函数

能定义成const的成员函数都应该定义成const，这样const对象和非const对象都可以调用
要修改成员变量的成员函数不能定义成const，const对象不能调用，非const对象才能调用

#include<iostream>  
using namespace std;  

class Date  
{ 
public:  
	Date(int year = 1, int month = 1, int day = 1)  
	{  
		_year = year;  
		_month = month;  
		_day = day;  
	} 
	
	// void Print(const Date* const this) const  
	void Print() const  
	{  
		cout << _year << "-" << _month << "-" << _day << endl;  
	}  

private:  
	int _year;  
	int _month;  
	int _day;  
};  

int main()  
{  
	// 这⾥⾮const对象也可以调⽤const成员函数是⼀种权限的缩⼩  
	Date d1(2024, 7, 5);  
	d1.Print();  
	const Date d2(2024, 8, 5);  
	d2.Print();  
	
	return 0;  
}

取地址运算符重载

取地址运算符重载分为普通取地址运算符重载和const取地址运算符重载，⼀般这两个函数编译器⾃动⽣成的就可以够我们⽤了，不需要去显⽰实现。除⾮⼀些很特殊的场景，⽐如我们不想让别⼈取到当前类对象的地址，就可以⾃⼰实现⼀份，胡乱返回⼀个地址。

class Date  
{ 
public :  
	Date* operator&()  
	{  
		return this;  
		// return nullptr;  
	} 
	
	const Date* operator&()const  
	{  
		return this;  
		// return nullptr;  
	}  
	
private :  
	int _year ; // 年  
	int _month ; // ⽉  
	int _day ; // ⽇  
};

再探构造函数

之前我们实现构造函数时，初始化成员变量主要使⽤函数体内赋值，构造函数初始化还有⼀种⽅式，就是初始化列表，初始化列表的使⽤⽅式是以⼀个冒号开始，接着是⼀个以逗号分隔的数据成员列表，每个"成员变量"后⾯跟⼀个放在括号中的初始值或表达式。
每个成员变量在初始化列表中只能出现⼀次，语法理解上初始化列表可以认为是每个成员变量定义初始化的地⽅。
引⽤成员变量，const成员变量，没有默认构造的类类型变量，必须放在初始化列表位置进⾏初始化，否则会编译报错。
C++11⽀持在成员变量声明的位置给缺省值，这个缺省值主要是给没有显⽰在初始化列表初始化的成员使⽤的。
尽量使⽤初始化列表初始化，因为那些你不在初始化列表初始化的成员也会⾛初始化列表，如果这个成员在声明位置给了缺省值，初始化列表会⽤这个缺省值初始化。如果你没有给缺省值，对于没有显⽰在初始化列表初始化的内置类型成员是否初始化取决于编译器，C++并没有规定。对于没有显⽰在初始化列表初始化的⾃定义类型成员会调⽤这个成员类型的默认构造函数，如果没有默认构造会编译错误。
初始化列表中按照成员变量在类中声明顺序进⾏初始化，跟成员在初始化列表出现的的先后顺序⽆关。建议声明顺序和初始化列表顺序保持⼀致。
初始化列表总结：
⽆论是否显⽰写初始化列表，每个构造函数都有初始化列表；
⽆论是否在初始化列表显⽰初始化成员变量，每个成员变量都要⾛初始化列表初始化；

函数体内初始化和初始化列表可以混着使用，剩下没有在初始化列表显示写出来的定义，编译器也会定义，只是内置类型默认给随机值，自定义类型成员会去调用默认构造函数
初始化列表解决的问题：

必须在定义的地方显示初始化，引用、const、没有默认构造的自定义成员
有些自定义成员想要显示初始化，自己控制
尽量使用初始化列表初始化
构造函数不能只要初始化列表，不要函数体初始化
因为有些初始化或检查工作，初始化列表不能全部搞定

#include<iostream>  
using namespace std;  

class Time  
{ 
public:  
	Time(int hour)  
		:_hour(hour)  
	{  
		cout << "Time()" << endl;  
	}  
	
private:  
	int _hour;  
};  

class Date  
{ 
public:  
	Date(int& x, int year = 1, int month = 1, int day = 1)  
		:_year(year)  
		,_month(month)  
		,_day(day)  
		,_t(12)  
		,_ref(x)  
		,_n(1)  
	{  
		// error C2512: “Time”: 没有合适的默认构造函数可⽤  
		// error C2530 : “Date::_ref” : 必须初始化引⽤  
		// error C2789 : “Date::_n” : 必须初始化常量限定类型的对象  
	} 
	
	void Print() const
	{  
		cout << _year << "-" << _month << "-" << _day << endl;  
	}  

private:  
	int _year;  
	int _month;  
	int _day;  
	
	Time _t;      // 没有默认构造
	int& _ref;    // 引⽤
	const int _n; // const  
};  

int main()  
{  
	int i = 0;  
	Date d1(i);  
	d1.Print();  
	
	return 0;  
}

#include<iostream>  
using namespace std;  

class Time  
{ 
public:  
	Time(int hour)  
		:_hour(hour)  
	{  
		cout << "Time()" << endl;  
	}  

private:  
	int _hour;  
};  

class Date  
{ 
public:  
	Date()  
		:_month(2)  
	{  
		cout << "Date()" << endl;  
	}
	
	void Print() const  
	{  
		cout << _year << "-" << _month << "-" << _day << endl;  
	}  

private:  
	// 注意这⾥不是初始化，这⾥给的是缺省值，这个缺省值是给初始化列表的  
	// 如果初始化列表没有显⽰初始化，默认就会⽤这个缺省值初始化  
	int _year = 1;  
	int _month = 1;  
	int _day;  
	Time _t = 1;  
	const int _n = 1;  
	int* _ptr = (int*)malloc(12);  
};  

int main()  
{  
	Date d1;  
	d1.Print();  
	
	return 0;  
}

下⾯程序的运⾏结果是什么（D）
A.输出 1 1
B.输出 2 2
C.编译报错
D.输出 1 随机值
E.输出 1 2
F.输出 2 1

#include<iostream>  
using namespace std;  

class A  
{ 
public:  
	A(int a)  
		:_a1(a)  
		, _a2(_a1)
	{}  
	
	void Print() {  
		cout << _a1 << " " << _a2 << endl;  
	}  

private:  
	int _a2 = 2;  
	int _a1 = 2;  
};  

int main()  
{  
	A aa(1);  
	aa.Print();  
}

成员变量在类中声明次序就是其在初始化列表的初始化顺序，与其在初始化列表中的先后次序无关

类型转换

C++⽀持内置类型隐式类型转换为类类型对象，需要有相关内置类型为参数的构造函数。
构造函数前⾯加explicit就不再⽀持隐式类型转换。
类类型的对象之间也可以隐式转换，需要相应的构造函数⽀持。

#include<iostream>  
using namespace std;  

class A  
{ 
public:  
	// 构造函数explicit就不再⽀持隐式类型转换  
	// explicit A(int a1)  
	A(int a1)  
		:_a1(a1)  
	{}  
	
	//explicit A(int a1, int a2)  
	A(int a1, int a2)  
		:_a1(a1)  
		, _a2(a2)  
	{}  
	void Print()  
	{  
		cout << _a1 << " " << _a2 << endl;  
	}
	
	int Get() const  
	{  
		return _a1 + _a2;  
	}  

private:  
	int _a1 = 1;  
	int _a2 = 2;  
};  

class B  
{ 
public:  
	B(const A& a)  
		:_b(a.Get())  
	{}  

private:  
	int _b = 0;  
};  

int main()  
{  
	// 内置类型对象 隐式转换为自定义类型对象
	// 1构造⼀个A的临时对象，再⽤这个临时对象拷⻉构造aa3  
	// 编译器遇到连续构造+拷⻉构造->优化为直接构造  
	A aa1 = 1;  
	aa1.Print();  
	
	const A& aa2 = 1;  
	
	// C++11之后才⽀持多参数转化  
	A aa3 = { 2,2 };  
	
	// aa3隐式类型转换为b对象  
	// 原理跟上⾯类似  
	B b = aa3;  
	const B& rb = aa3;  
	
	return 0;  
}

内置类型，整形和浮点隐式互相转