文章目录
- 一、类的6个默认成员函数
- 二、日期类的实现
- 2.1 运算符重载部分
- 2.2 日期之间的运算
- 2.3 整体代码
- 1.Date.h部分
- 2. Date.cpp部分
- 三. const成员函数
- 四. 取地址及const取地址操作符重载
- 扩展内容
- 总结
ヾ(๑╹◡╹)ﾉ" 人总要为过去的懒惰而付出代价ヾ(๑╹◡╹)ﾉ"
一、类的6个默认成员函数
如果一个类中什么成员都没有，简称为空类。
空类中并不是什么都没有,任何类在什么都不写时，编译器会自动生成以下6个默认成员函数。
默认成员函数：用户没有显式实现，编译器会生成的成员函数称为默认成员函数
二、日期类的实现
2.1 运算符重载部分
- inline不支持声明与定义分离，所以成员函数要成为inline，最好直接在类里面定义
- 类里面定义成员函数的默认就是inline。代码较长的部分采用声明与定义分离的方法
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);
- 运算符重载部分【比较大小】，能复用其他函数的时候，尽可能的去复用
- 此部分写一个小于等于，那么别的函数就都可以复用
- 内联函数声明定义不能分离(符号表里没有函数的地址，所以使用的时候找不到函数定义)，所以这部分代码，如果想设置成inline函数，就直接放到类里面。内联函数是在调用的地方，被展开，以空间换取时间的方法
- 类里面的函数默认是内联函数
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;
}
- 运算法重载部分【比较大小】
因为代码较长，不适合用inline函数，所以使用声明与定义的方法【==和<的代码更加容易实现】
- 运算符重载部分【+、+=、-、-=】
- d1=10，注意：这里是+和-，并不是+=和-=,所以d1是不变的，不要对d1直接进行改动。【利用拷贝构造】
- +和+=之间和-和-=之间可以相互复用【写整块代码的时候，代码之间能相互复用，就相互复用【即简单又很大程度上保证了代码的正确性】】【+复用+=更优】
- 加减法注意：这里的day要求必须是正数，否则减去一个负数，相当于加上一个正数；加上一个负数，相当于减去一个正数（相互复用即可）【因为-复用-=，所以-的函数就不用考虑负数问题】
补充知识点（1）：
Date d1(2000， 9， 17）； Date d2 = d1;//这里是拷贝构造，不是赋值【因为一个已经创建的对象去初始化另一个对象就是拷贝构造】
【赋值是两个已经创建好的对象进行初始化】
补充知识点（2）:
写赋值重载函数和拷贝构造函数时，函数的形参要加const，因为既可以防止修改值，又可以防止当形参是函数的返回值【具有const属性】，会权限扩大，导致错误【无法修改的右值】。
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。【普通对象和const对象都可以调用】 不加const，那么const修饰的对象就没有办法调用成员函数
1. const对象可以调用非const成员函数吗？不可以，权限放大不可以
2. 非const对象可以调用const成员函数吗？可以，权限缩小可以
3. const成员函数内可以调用其它的非const成员函数吗？不可以，权限放大
4. 非const成员函数内可以调用其它的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++类和对象】类有哪些默认成员函数呢？（上）】详细的介绍了类的默认成员函数，希望给友友们带来帮助！
