是小刘同学啦

是小刘同学啦

关注
发信
关注(28)粉丝(399)

【C++类和对象】类有哪些默认成员函数呢？（下）

一、类的6个默认成员函数

如果一个类中什么成员都没有，简称为空类。

空类中并不是什么都没有,任何类在什么都不写时，编译器会自动生成以下6个默认成员函数。
​​​​​​​​【C++类和对象】类有哪些默认成员函数呢？（下）-LMLPHP
默认成员函数：用户没有显式实现，编译器会生成的成员函数称为默认成员函数

二、日期类的实现

2.1 运算符重载部分

1. 运算符重载部分1
此部分在Date.h类里面部分

//运算符重载部分1
	bool operator==(const Date& d);
	bool operator<(const Date& d);
	
	bool operator>(const Date& d)
	{
		return !(*this <= d);
	}
	bool operator>=(const Date& d)
	{
		return !(*this < d);
	}
	bool operator!=(const Date& d)
	{
		return !(*this == d);
	}
	//思路：把小于的情况写出来，剩下的就是大于的情况
	bool operator<=(const Date& d)
	{
		return *this < d || *this == d;//this是一个指针，指向类的指针
		//小于和等于都已经实现过了，所以就可以复用
	}
	//运算符重载部分，【+-】
	Date operator+(int day) const;
	Date& operator+=(int day);
	Date operator-(int day) const;
	Date& operator-=(int day);

2. 运算符重载部分2
此部分在Date.cpp部分

//运算符重载部分2，==和<部分，
bool Date::operator==(const Date& d)//访问的本质上是：this->_year == d._year(一个是指针访问，一个是类直接访问)……
	//_year并不是类里面的_year(仅仅是一个声明)，而是比较的另一个类
{
	if (_year == d._year
		&& _month == d._month
		&& _day == d._day)
	{
		return true;
	}
	else
	{
		return false;
	}
}
bool Date::operator<(const Date& d)//要加上Date::(在类外面写)
{
	if (_year < d._year
		|| (_year == d._year && _month < d._month)
		|| (_year == d._year && _month == d._month && _day < d._day))
	{
		return true;
	}
	else
	{
		return false;
	}
}
//运算符重载
//d1+2=d2;因为此处运算符是+，d1是不变的，所以，不能直接对d1进行改动
Date Date::operator+(int day) const//这里的返回值不能用Date&，因为出了函数，空间就被回收了
{
	//+复用+=
	Date ret(*this);//拷贝构造
	ret += day;
	return ret;
	//Date ret(*this);//拷贝构造
	//ret._day += day;
	//while (ret._day > GetMonthDay(ret._year, ret._month))
	//{
	//	ret._day = ret._day - GetMonthDay(ret._year, ret._month);
	//	ret._month++;
	//	while (ret._month > 13)
	//	{
	//		ret._month = 1;
	//		ret._year++;
	//	}
	//}
	//return ret;
}


Date& Date::operator+=(int day)//因为出了作用域this还在，所以用引用比较好【在能用引用的情况下，尽可能去用引用】
{
	//+=复用+
	//*this = *this + day;
	//return *this;
	if (day < 0)
	{
		return *this -= -day;
	}
	_day += day;
	while (_day > GetMonthDay(_year, _day))
	{
		_day -= GetMonthDay(_year, _day);
		_month++;
		if (_month = 13)
		{
			_month = 1;
			_year++;
		}
	}
	return *this;
}

Date Date::operator-(int day) const
{
	Date ret(*this);
	ret -= day;
	return ret;
}
Date& Date::operator-=(int day)
{
	if (day < 0)
	{
		return *this += -day;
	}
    _day -= day;
	while (_day <= 0)//日期是不能有0日的
	{
		_month--;
		while (_month == 0)
		{
			_month = 12;
			_year--;
		}
		_day += GetMonthDay(_year, _month);
	}
	return *this;
}

2.2 日期之间的运算

前置++后置++，前置–，后置–【区分++是前置还是后置的，函数重载】
C++用无参数的代表前置，有一个参数的代表后置【参数只要是int类型的就符合要求，无论是整形的哪一个数字】
1. 日期之间的运算1
此部分在Date.h类里面部分
Date.h

//日期之间的运算
	Date& operator++()
	{
		*this += 1;
		return *this;
	}

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

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

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

	//日期-日期
	int operator-(const Date& d) const;

2. 日期之间的运算2
此部分在Date.cpp里面部分
Date.c

//*this和d不确定哪一个日期大
int Date::operator-(const Date& d) const
{
	int day = 0;
	int flag = 1;
	Date max = *this;
	Date min = d;
	if (*this < d)
	{
		max = d;
		min = *this;
		flag = -1;
	}
	while (min != max)
	{
		min++;
		day++;
	}
	day = day * flag;
	return day;
}

2.3 整体代码

1.Date.h部分

#pragma once

#include <iostream>
#include <assert.h>
using std::cin;
using std::cout;//在正式的项目中不要全展开
using std::endl;

class Date
{
public:
	//拷贝构造函数部分
	//判断是否是闰年
	bool isLeapYear(int year)
	{
		if (year % 4 == 0 && year % 100 != 0
			&& year % 400 == 0)
		{
			return true;
		}
		return false;
	}
	//每一月的天数
	int GetMonthDay(int year, int month);
	//构造函数(也可以不用写)//可能会有用户输入非法日期
	Date(int year = 1, int month = 1, int day = 1);
	//拷贝构造函数(也可以不用写),值拷贝
	Date(const Date& d)
	{
		_year = d._year;
		_month = d._month;
		_day = d._day;
	}

	//赋值运算符重载
	Date& operator=(const Date& d)
	{
		if (this != &d)
		{
			_year = d._year;
			_month = d._month;
			_day = d._day;
		}
	    return *this;
	}
	
	//不需要写析构函数，没有资源清理


	//打印Date,在函数后面加一个const,相当于void print(const Date* const d)，const对象和普通对象都可以调用此函数
	//如果不加const，相当于void print(Date* const d),
	//只要不修改this，就可以加上
	void print() const
	{
		cout << _year << "-" << _month << "-" << _day << endl;
	}
	//运算符重载部分，【+-】
	Date operator+(int day) const;
	Date& operator+=(int day);
	Date operator-(int day) const;
	Date& operator-=(int day);
	
	//运算符重载部分1【比较大小】
	bool operator==(const Date& d) const;
	bool operator<(const Date& d) const;

	bool operator>(const Date& d) const
	{
		return !(*this <= d);
	}
	bool operator>=(const Date& d) const
	{
		return !(*this < d);
	}
	bool operator!=(const Date& d) const
	{
		return !(*this == d);
	}
	//思路：把小于的情况写出来，剩下的就是大于的情况
	bool operator<=(const Date& d) const
	{
		return *this < d || *this == d;//this是一个指针，指向类的指针
		//小于和等于都已经实现过了，所以就可以复用
	}

	//日期之间的运算
	Date& operator++()
	{
		*this += 1;
		return *this;
	}

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

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

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

	//日期-日期
	int operator-(const Date& d) const;

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

2. Date.cpp部分

#define _CRT_SECURE_NO_WARNINGS 1
#include "Date.h"

//构造函数部分
Date::Date(int year = 1, int month = 1, int day = 1)
{
	if (year >= 1
		&& (month >= 1 && month <= 12)
		&& (day >= 1 && day <= GetMonthDay(year, month)))
	{
		_year = year;
		_month = month;
		_day = day;
	}
	else
	{
		cout << "日期非法" << endl;
	}
}
int Date::GetMonthDay(int year, int month)
{
	assert(year > 0 && month >= 1 && month < 13);
	static int monthDayArray[13] = { 0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };
	//因为这部分空间需要频繁开辟，所以就用static，就可以节约时间
	if (month == 2 && isLeapYear(year))
	{
		return 29;
	}
	else
	{
		return monthDayArray[month];
	}
}


//运算符重载部分2，
bool Date::operator==(const Date& d) const//访问的本质上是：this->_year == d._year(一个是指针访问，一个是类直接访问)……
	//_year并不是类里面的_year(仅仅是一个声明)，而是比较的另一个类
{
	if (_year == d._year
		&& _month == d._month
		&& _day == d._day)
	{
		return true;
	}
	else
	{
		return false;
	}
}
bool Date::operator<(const Date& d) const//要加上Date::(在类外面写)
{
	if (_year < d._year
		|| (_year == d._year && _month < d._month)
		|| (_year == d._year && _month == d._month && _day < d._day))
	{
		return true;
	}
	else
	{
		return false;
	}
}

//运算符重载
//d1+2=d2;因为此处运算符是+，d1是不变的，所以，不能直接对d1进行改动
Date Date::operator+(int day) const//这里的返回值不能用Date&，因为出了函数，空间就被回收了
{
	//+复用+=
	Date ret(*this);//拷贝构造
	ret += day;
	return ret;
	//Date ret(*this);//拷贝构造
	//ret._day += day;
	//while (ret._day > GetMonthDay(ret._year, ret._month))
	//{
	//	ret._day = ret._day - GetMonthDay(ret._year, ret._month);
	//	ret._month++;
	//	while (ret._month > 13)
	//	{
	//		ret._month = 1;
	//		ret._year++;
	//	}
	//}
	//return ret;
}


Date& Date::operator+=(int day)//因为出了作用域this还在，所以用引用比较好【在能用引用的情况下，尽可能去用引用】
{
	//+=复用+
	//*this = *this + day;
	//return *this;
	if (day < 0)
	{
		return *this -= -day;
	}
	_day += day;
	while (_day > GetMonthDay(_year, _day))
	{
		_day -= GetMonthDay(_year, _day);
		_month++;
		if (_month = 13)
		{
			_month = 1;
			_year++;
		}
	}
	return *this;
}

Date Date::operator-(int day) const
{
	Date ret(*this);
	ret -= day;
	return ret;
}
Date& Date::operator-=(int day)
{
	if (day < 0)
	{
		return *this += -day;
	}
    _day -= day;
	while (_day <= 0)//日期是不能有0日的
	{
		_month--;
		while (_month == 0)
		{
			_month = 12;
			_year--;
		}
		_day += GetMonthDay(_year, _month);
	}
	return *this;
}

//*this和d不确定哪一个日期大
int Date::operator-(const Date& d) const
{
	int day = 0;
	int flag = 1;
	Date max = *this;
	Date min = d;
	if (*this < d)
	{
		max = d;
		min = *this;
		flag = -1;
	}
	while (min != max)
	{
		min++;
		day++;
	}
	day = day * flag;
	return day;
}

三. const成员函数

将const修饰的类成员函数称之为const成员函数，const修饰类成员函数，实际修饰该成员函数隐含的this指针，表明在该成员函数中不能对类的任何成员进行修改。
Date类中的打印函数中

	void print() const
	{
		cout << _year << "-" << _month << "-" << _day << endl;
	}
  • 打印Date,在函数后面加一个const,相当于void print(const Date* const d)，const对象和普通对象都可以调用此函数
  • 如果不加const，相当于void print(Date* const d),
  • 只要不修改this，就可以加上const
  • （d+13).print();会报错，因为d+13是传值返回，传值返回的是临时拷贝，临时拷贝具有常性。【在print没有加const的情况下】

四. 取地址及const取地址操作符重载

这两个默认成员函数一般不用重新定义 ，编译器默认会生成。

	Date* operator&()
	{
		return this;
	}//取地址重载

	const Date* operator&() const
	{
		return this;
	}//const取地址重载

这两个运算符一般不需要重载，使用编译器生成的默认取地址的重载即可，只有特殊情况，才需要重载，比如想让别人获取到指定的内容【不想要输出地址，而是别的内容】！【此时才需要我们自己写】

扩展内容

流插入运算符和流提取运算符重载
d1.operator<<(cout);//test函数中写，可以运行
cout<<d1;//不可以运行
void operator<<(std::ostream out)
{
out << _year<< “- “<< _month<<” -” << _day<<endl;
}
Date.h 类里面

//友元函数
	friend std::ostream& operator<<(std::ostream& out, const Date& d);
	friend std::istream& operator>>(std::istream& in, Date& d);

Date.cpp

std::ostream& operator<<(std::ostream& out, const Date& d)
{
	out << d._year << "-" << d._month << "-" << d._day << endl;
	return out;
}
std::istream& operator>>(std::istream& in, Date& d)
{
	in >> d._year >> d._month >> d._day;
	return in;
}
  • 内置类型直接支持流插入和流提取【且自动识别类型，因为函数重载】
  • 全局变量函数不要放在.h里面，因为在别的文件展开的时候，会出现多个符号表里，导致重定义。【只有声明的时候，才会链接的时候去找函数】

总结

以上就是今天的所有内容了，类的默认成员函数就到此结束了。本文以及【C++类和对象】类有哪些默认成员函数呢？（上）】详细的介绍了类的默认成员函数，希望给友友们带来帮助！

08-18 22:17
Powered by LMLPHP ©2024 是小刘同学啦 0.007759