C++ 复习总结记录三

C++ 复习总结记录三

主要内容
1、类的六个默认成员函数
2、构造函数
3、析构函数
4、拷贝构造函数
5、赋值运算符重载
6、const 成员函数
7、取所在及 const 取所在操纵符重载
一 类的六个默认成员函数

如果一个类中什么成员都没有，简称为空类。空类中并不是什么都没有，编译器会自动生成六个默认成员函数（用户没有显式实现，编译器自动生成的成员函数称为默认成员函数）

1. class Date {};

复制代码

六个默认成员函数

1. //初始化和清理
2. 构造函数，完成初始化
3. 析构函数，完成清理
5. //拷贝复制
6. 拷贝构造函数，使用同类对象初始化创建对象
7. 赋值重载，把一个对象赋值给另一个对象
9. //取地址重载
10. 普通取地址函数
11. const 取地址函数

复制代码

二 构造函数

2.1 概念

构造函数是一个特殊的成员函数，名字与类名雷同，创建类范例对象时由编译器自动调用，以保证每个数据成员都有 一个符合的初始值，而且在对象整个生命周期内只调用一次
注意，构造函数固然名称叫构造，但是构造函数任务不是开空间创建对象，而是初始化对象，特征如下
1、函数名与类名雷同
2、无返回值
3、对象实例化时编译器自动调用其构造函数
4、构造函数可以重载

1. class Date
2. {
3. public:
4.     // 1.无参构造函数
5.     Date() {}
7.     // 2.带参构造函数
8.     Date(int year, int month, int day)
9.     {
10.         _year = year;
11.         _month = month;
12.         _day = day;
13.     }
15. private:
16.     int _year;
17.     int _month;
18.     int _day;
19. };
21. void TestDate()
22. {
23.     Date d1; // 调用无参构造函数
24.     Date d2(2015, 1, 1); // 调用带参的构造函数
25. }

复制代码

2.2 注意要点

注意 : 如果通过无参构造函数创建对象时，对象后面不消跟括号，否则就成了函数声明

1. void TestDate()
2. {
3.         //warning C4930: “Date d3(void)”: 未调用原型函数
4.         //以下代码的函数 : 声明了d3函数, 该函数无参, 返回一个日期类型对象
5.     Date d3();
6. }

复制代码

类中没有显式定义构造函数，编译器会自动生成一个无参的默认构造函数，一旦显式定义编译器将不再生成

1. class Date
2. {
3. public:
4.     // 如果用户显式定义了构造函数，编译器将不再生成
5.     /*
6.      Date(int year, int month, int day)
7.      {
8.          _year = year;
9.          _month = month;
10.          _day = day;
11.      }
12.         */
14.     void Print()
15.     {
16.         cout << _year << "-" << _month << "-" << _day << endl;
17.     }
19. private:
20.     int _year;
21.     int _month;
22.     int _day;
23. };
25. int main()
26. {
27.     // 将 Date 类中构造函数屏蔽后，代码可以通过编译，因为编译器生成了一个无参的默认构造函数
28.     // 将 Date 类中构造函数放开，代码编译失败，因为一旦显式定义任何构造函数，编译器将不再生成
29.     // 无参构造函数，放开后报错：error C2512: “Date”: 没有合适的默认构造函数可用
30.     Date d1;
31.     return 0;
32. }

复制代码

2.3 默认构造函数作用

C++ 把范例分成内置范例（根本范例，语言提供的数据范例，如 int / char … 等）和自定义范例（ class / struct / union 等自定义的范例），默认构造函数会对自定范例成员调用它的默认构造函数

1. class Time
2. {
3. public:
4.     Time()
5.     {
6.         cout << "Time()" << endl;
7.         _hour = 0;
8.         _minute = 0;
9.         _second = 0;
10.     }
11.    
12. private:
13.     int _hour;
14.     int _minute;
15.     int _second;
16. };
18. class Date
19. {
20. private:
21.     // 基本类型(内置类型)
22.     int _year;
23.     int _month;
24.     int _day;
25.     // 自定义类型
26.     Time _t;
27. };
28. int main()
29. {
30.     Date d;
31.     return 0;
32. }

复制代码

注意：C++11 中针对内置范例成员不初始化的缺陷打了补丁，内置范例成员变量在类中声明时可给默认值

1. class Time
2. {
3. public:
4.     Time()
5.     {
6.         cout << "Time()" << endl;
7.         _hour = 0;
8.         _minute = 0;
9.         _second = 0;
10.     }
11.    
12. private:
13.     int _hour;
14.     int _minute;
15.     int _second;
16. };
18. class Date
19. {
20. private:
21.     // 基本类型(内置类型)
22.     int _year = 1970;
23.     int _month = 1;
24.     int _day = 1;
25.     // 自定义类型
26.     Time _t;
27. };
29. int main()
30. {
31.     Date d;
32.     return 0;
33. }

复制代码

2.4 默认构造函数

无参构造函数、全缺省构造函数、编译器默认生成的构造函数，都是默认构造函数，且默认构造函数只能有一个

1. class Date
2. {
3. public:
4.     Date()
5.     {
6.         _year = 1900;
7.         _month = 1;
8.         _day = 1;
9.     }
10.    
11.     Date(int year = 1900, int month = 1, int day = 1)
12.     {
13.         _year = year;
14.         _month = month;
15.         _day = day;
16.     }
17.    
18. private:
19.     int _year;
20.     int _month;
21.     int _day;
22. };
24. void Test()
25. {
26.     Date d1; //Date包含多个构造函数, 无法通过编译
27. }

复制代码

三 析构函数

3.1 概念

析构函数：与构造函数功能相反，完成对象中资源的清理工作
它不是完成对对象本身的销毁，局部对象销毁工作由编译器完成，对象在销毁时会自动调用析构函数
析构函数特征如下
1、析构函数名是在类名前加上字符 ~
2、无参数无返回值范例
3、一个类只能有一个析构函数，若未显式定义，系统会自动生成默认析构函数（注意：析构函数不能重载）
4、对象生命周期竣事时，编译器自动调用析构函数

1. typedef int DataType;
2. class Stack
3. {
4. public:
5.     Stack(size_t capacity = 3)
6.     {
7.         _array = (DataType*)malloc(sizeof(DataType) * capacity);
8.         if (NULL == _array)
9.         {
10.             perror("malloc申请空间失败!!!");
11.             return;
12.         }
13.         _capacity = capacity;
14.         _size = 0;
15.     }
16.    
17.     void Push(DataType data)
18.     {
19.         // CheckCapacity();
20.         _array[_size] = data;
21.         _size++;
22.     }
23.    
24.     // 其他方法...
25.     ~Stack()
26.     {
27.         if (_array)
28.         {
29.             free(_array);
30.             _array = NULL;
31.             _capacity = 0;
32.             _size = 0;
33.         }
34.     }
35.    
36. private:
37.     DataType* _array;
38.     int _capacity;
39.     int _size;
40. };
42. void TestStack()
43. {
44.     Stack s;
45.     s.Push(1);
46.     s.Push(2);
47. }

复制代码

3.2 默认析构函数作用

默认析构函数，对自定范例成员调用它的析构函数

1. class Time
2. {
3. public:
4.     ~Time()
5.     {
6.         cout << "~Time()" << endl;
7.     }
8. private:
9.     int _hour;
10.     int _minute;
11.     int _second;
12. };
14. class Date
15. {
16. private:
17.     // 基本类型(内置类型)
18.     int _year = 1970;
19.     int _month = 1;
20.     int _day = 1;
21.     // 自定义类型
22.     Time _t;
23. };
25. int main()
26. {
27.     Date d;
28.     return 0;
29. }

复制代码

注：类中没有申请资源时，析构函数可以不写，直接使用编译器生成的默认析构函数即可，好比 Date 类（成员均为内置范例）；有资源申请时，析构函数必须写，否则会造成资源走漏，好比 Stack 类
3.3 训练

两个栈实现一个队列
使用 STL 库

1. #include <stack>
2. using namespace std;
3. class MyQueue {
4. public:
5.     MyQueue() {
7.     }
9.     void push(int x) {
10.         s1.push(x);
11.     }
13.     int pop() {
14.         int res = peek();
15.         s2.pop();
16.         return res;
17.     }
19.     int peek() {
20.         if (s2.empty()) //先判断 s2 是否为空, 若 s2 不为空直接输出 s2 栈顶元素
21.         {
22.             while (!s1.empty()) //s2 为空则将 s1 的内容入 s2 栈
23.             {
24.                 s2.push(s1.top());
25.                 s1.pop();
26.             }
27.         }
28.         return s2.top();
29.     }
31.     bool empty() {
32.         return s1.empty() && s2.empty();
33.     }
35. private:
36.     stack<int> s1, s2;
37. };

复制代码

提交截图

C 自实现栈

1. #define MAX_LEN 10
2. typedef int DataType;
4. class MyStack
5. {
6. public:
7.     MyStack()
8.         : _array((DataType*)malloc(_capacity * sizeof(DataType)))
9.     {
10.         if (nullptr == _array)
11.         {
12.             perror("malloc申请空间失败");
13.             return;
14.         }
15.     }
17.     ~MyStack()
18.     {
19.         if (_array) {
20.             free(_array);
21.             _array = nullptr;
22.         }
23.         
24.     }
26.     void push(const DataType& x) {
27.         _array[_size] = x;
28.         ++_size;
30.         if (_size > _capacity)
31.         {
32.             _capacity *= 2;
33.             DataType*  tmpPtr = (DataType*)malloc(sizeof(DataType) * _capacity);
34.             memcpy(tmpPtr, _array, sizeof(DataType) * _capacity / 2);
35.             free(_array);
36.             _array = tmpPtr;
37.         }
38.     }
40.     void pop() {
41.         --_size;
42.     }
44.     int top() {
45.         return _array[_size - 1];
46.     }
48.     bool empty() {
49.         return _size == 0;
50.     }
52. private:
53.     int _size = 0;
54.     int _capacity = MAX_LEN;
55.     DataType* _array; //类型数组
56. };
58. class MyQueue {
59. public:
60.     MyQueue() {
62.     }
64.     void push(int x) {
65.         s1.push(x);
66.     }
68.     int pop() {
69.         int res = peek();
70.         s2.pop();
71.         return res;
72.     }
74.     int peek() {
75.         if (s2.empty()) //先判断 s2 是否为空, 若 s2 不为空直接输出 s2 栈顶元素
76.         {
77.             while (!s1.empty()) //s2 为空则将 s1 的内容入 s2 栈
78.             {
79.                 s2.push(s1.top());
80.                 s1.pop();
81.             }
82.         }
83.         return s2.top();
84.     }
86.     bool empty() {
87.         return s1.empty() && s2.empty();
88.     }
90. private:
91.     MyStack s1, s2;
92. };

复制代码

提交截图

四 拷贝构造函数

4.1 概念

拷贝构造函数
单个形参，该形参是对本类范例对象的引用 ( 一样平常常用 const 修饰 )，用已存在的对象创建新对象
特征
1、拷贝构造函数是构造函数的一个重载
2、拷贝构造函数参数只有一个且必须是范例对象引用（传值方式编译器直接报错，会引发无穷递归调用）

1. class Date
2. {
3. public:
4.     Date(int year = 1900, int month = 1, int day = 1)
5.     {
6.         _year = year;
7.         _month = month;
8.         _day = day;
9.     }
10.     // Date(const Date& d)   // 正确写法
11.     Date(const Date& d)   // 错误写法：编译报错，会引发无穷递归
12.     {
13.         _year = d._year;
14.         _month = d._month;
15.         _day = d._day;
16.     }
17.    
18. private:
19.     int _year;
20.     int _month;
21.     int _day;
22. };
24. int main()
25. {
26.     Date d1;
27.     Date d2(d1);
28.     return 0;
29. }

复制代码

4.2 默认拷贝构造函数

若未显式定义，编译器会生成默认的拷贝构造函数
注意：编译器生成的默认拷贝构造函数中，内置范例按照字节方式直接拷贝（浅拷贝或值拷贝），而自定义范例是调用其拷贝构造函数完成拷贝

1. class Time
2. {
3. public:
4.     Time()
5.     {
6.         _hour = 1;
7.         _minute = 1;
8.         _second = 1;
9.     }
10.    
11.     Time(const Time& t)
12.     {
13.         _hour = t._hour;
14.         _minute = t._minute;
15.         _second = t._second;
16.         cout << "Time::Time(const Time&)" << endl;
17.     }
18.    
19. private:
20.     int _hour;
21.     int _minute;
22.     int _second;
23. };
25. class Date
26. {
27. private:
28.     // 基本类型(内置类型)
29.     int _year = 1970;
30.     int _month = 1;
31.     int _day = 1;
32.     // 自定义类型
33.     Time _t;
34. };
36. int main()
37. {
38.     Date d1;
39.     // 用已经存在的 d1 拷贝构造 d2, 此处会调用 Date 类的拷贝构造函数
40.     // 但 Date 类并没有显式定义拷贝构造函数, 则编译器会给 Date 类生成一个默认的拷贝构造函数
41.     Date d2(d1);
42.     return 0;
43. }

复制代码

注意：类中如果没有涉及资源申请时，拷贝构造函数是否写都可以；一旦涉及到资源申请时，则拷贝构造函数必须写，否则就是浅拷贝，如下例

1. typedef int DataType;
2. class Stack
3. {
4. public:
5.     Stack(size_t capacity = 10)
6.     {
7.         _array = (DataType*)malloc(capacity * sizeof(DataType));
8.         if (nullptr == _array)
9.         {
10.             perror("malloc申请空间失败");
11.             return;
12.         }
13.         _size = 0;
14.         _capacity = capacity;
15.     }
16.    
17.     void Push(const DataType& data)
18.     {
19.         // CheckCapacity();
20.         _array[_size] = data;
21.         _size++;
22.     }
23.    
24.     ~Stack()
25.     {
26.         if (_array)
27.         {
28.             free(_array);
29.             _array = nullptr;
30.             _capacity = 0;
31.             _size = 0;
32.         }
33.     }
34.    
35. private:
36.     DataType *_array;
37.     size_t _size;
38.     size_t _capacity;
39. };
41. int main()
42. {
43.     Stack s1;
44.     s1.Push(1);
45.     s1.Push(2);
46.     s1.Push(3);
47.     s1.Push(4);
48.     Stack s2(s1);
49.     return 0;
50. }

复制代码

将会导致瓦解

4.3 典范调用场景

1、使用已存在对象创建新对象
2、函数参数范例为类范例对象
3、函数返回值范例为类范例对象

1. class Date
2. {
3. public:
4.     Date(int year, int minute, int day)
5.     {
6.         cout << "Date(int,int,int):" << this << endl;
7.     }
8.    
9.     Date(const Date& d)
10.     {
11.         cout << "Date(const Date& d):" << this << endl;
12.     }
13.    
14.     ~Date()
15.     {
16.         cout << "~Date():" << this << endl;
17.     }
18.    
19. private:
20.     int _year;
21.     int _month;
22.     int _day;
23. };
25. Date Test(Date d)
26. {
27.     Date temp(d);
28.     return temp;
29. }
31. int main()
32. {
33.     Date d1(2022,1,13);
34.     Test(d1);
35.     return 0;
36. }

复制代码

为了提高步调效率，一样平常对象传参时，尽量使用引用范例，返回时根据实际场景，能用引用尽量使用引用（只要是不函数内部栈对象，均可使用引用）
五 赋值运算符重载

5.1 运算符重载

C++为增强代码可读性引入了运算符重载**，**运算符重载是具有特殊函数名的函数
   函数名字为：关键字 operator 后面接需要重载的运算符符号
  函数原型：返回值范例 operator操纵符 ( 参数列表 )
  注意

• 不能通过连接其他符号来创建新的操纵符：好比operator@
  
• 重载操纵符必须有一个类范例参数
  
• 用于内置范例的运算符，其含义不能改变，例如：内置的整型+，不 能改变其含义
  
• 作为类成员函数重载时，其形参看起来比操纵数数目少一，因为成员函数的第一个参数为隐蔽的 this
  
• .* :: sizeof ?: . 以上5个运算符不能重载
  

1. // 全局的 operator==
2. class Date
3. {
4. public:
5.     Date(int year = 1900, int month = 1, int day = 1)
6.     {
7.         _year = year;
8.         _month = month;
9.         _day = day;
10.     }   
12. //private:
13.     int _year;
14.     int _month;
15.     int _day;
16. };
18. //全局运算符重载需要成员变量是公有的, 不能保证封装性, 如何解决 ?
19. //可以用友元解决或重载成成员函数
20. bool operator==(const Date& d1, const Date& d2)
21. {
22.     return d1._year == d2._year
23.         && d1._month == d2._month
24.         && d1._day == d2._day;
25. }
27. void Test ()
28. {
29.     Date d1(2018, 9, 26);
30.     Date d2(2018, 9, 27);
31.     cout << (d1 == d2) << endl;
32. }

复制代码

如下

1. class Date
2. {
3. public:
4.     Date(int year = 1900, int month = 1, int day = 1)
5.     {
6.         _year = year;
7.         _month = month;
8.         _day = day;
9.     }
11.     //bool operator == (Date* this, const Date& d2)
12.     //注意左操作数是 this, 指向调用函数的对象
13.     bool operator==(const Date& d2)
14.     {
15.         return _year == d2._year;
16.         && _month == d2._month
17.             && _day == d2._day;
18.     }
19.    
20. private:
21.     int _year;
22.     int _month;
23.     int _day;
24. };

复制代码

5.2 赋值运算符重载

1、赋值运算符重载格式
参数范例：const T&，传递引用提高传参效率
返回值范例：T& 返回引用提高效率，有返回值为了支持连续赋值
检测是否本身给本身赋值
返回 *this 要复合连续赋值的含义

1. class Date
2. {
3. public :
4.     Date(int year = 1900, int month = 1, int day = 1)
5.     {
6.         _year = year;
7.         _month = month;
8.         _day = day;
9.     }
11.     Date (const Date& d)
12.     {
13.         _year = d._year;
14.         _month = d._month;
15.         _day = d._day;
16.     }
18.     Date& operator=(const Date& d)
19.     {
20.         if(this != &d)
21.         {
22.             _year = d._year;
23.             _month = d._month;
24.             _day = d._day;
25.         }
27.         return *this;
28.     }
29.    
30. private:
31.     int _year ;
32.     int _month ;
33.     int _day ;
34. };

复制代码

2、赋值运算符只能重载为类成员函数不能重载为全局函数

1. class Date
2. {
3. public:
4.     Date(int year = 1900, int month = 1, int day = 1)
5.     {
6.         _year = year;
7.         _month = month;
8.         _day = day;
9.     }
10.     int _year;
11.     int _month;
12.     int _day;
13. };
15. // 赋值运算符重载为全局函数, 注意没有 this 指针, 需要给两个参数
16. Date& operator=(Date& left, const Date& right)
17. {
18.     if (&left != &right)
19.     {
20.         left._year = right._year;
21.         left._month = right._month;
22.         left._day = right._day;
23.     }
24.     return left;
25. }
27. // 编译失败：
28. // error C2801: “operator =”必须是非静态成员

复制代码

原因：赋值运算符如果不显式实现，编译器会生成一个默认的。此时再在类外实现一个全局赋值运算符重载，和编译器生成的默认赋值运算符重载冲突，故赋值运算符重载只能是类的成员函数
C++ PRIME 第五版 500 页

3、默认赋值运算符重载
没有显式实现时，编译器会生成一个默认赋值运算符重载，以值的方式逐字节拷贝。注意：内置范例成员变量是直接赋值的，而自定义范例成员变量需要调用对应类的赋值运算符重载完成赋值（和类似拷贝构造）
5.3 前置++ 和后置++ 重载

1. class Date
2. {
3. public:
4.     Date(int year = 1900, int month = 1, int day = 1)
5.     {
6.         _year = year;
7.         _month = month;
8.         _day = day;
9.     }
10.     // 前置++: 返回 +1 之后的结果
11.     // 注意: this 指向的对象函数结束后不会销毁, 以引用方式返回提高效率
12.     Date& operator++()
13.     {
14.         _day += 1;
15.         return *this;
16.     }
17.    
18.     // 后置++
19.     // 前置++ 和后置++ 都是一元运算符, 为了让前置++ 与后置++ 形成能正确重载, C++ 规定后置++ 重载时多增加一个 int 类型参数, 但调用函数时该参数不用传递，编译器自动传递
20.     // 注意: 后置++ 是先使用后 +1, 因此需要返回 +1 之前的旧值, 故需在实现时需要先将 this 保存一份, 然后给 this + 1. 而 temp 是临时对象, 因此只能以值的方式返回, 不能返回引用
21.     Date operator++(int)
22.     {
23.         Date temp(*this);
24.         _day += 1;
25.         return temp;
26.     }
28. private:
29.     int _year;
30.     int _month;
31.     int _day;
32. };
34. int main()
35. {
36.     Date d;
37.     Date d1(2022, 1, 13);
38.     d = d1++;    // d: 2022,1,13   d1:2022,1,14
39.     d = ++d1;    // d: 2022,1,15   d1:2022,1,15
40.     return 0;
41. }

复制代码

六 const 成员

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

针对以下代码

1. class Date
2. {
3. public:
4.     Date(int year, int month, int day)
5.     {
6.         _year = year;
7.         _month = month;
8.         _day = day;
9.     }
10.    
11.     void Print()
12.     {
13.         cout << "Print()" << endl;
14.         cout << "year:" << _year << endl;
15.         cout << "month:" << _month << endl;
16.         cout << "day:" << _day << endl;
17.     }
18.    
19.     void Print() const
20.     {
21.         cout << "Print() const" << endl;
22.         cout << "year:" << _year << endl;
23.         cout << "month:" << _month << endl;
24.         cout << "day:" << _day << endl;
25.     }
26.    
27. private:
28.     int _year; // 年
29.     int _month; // 月
30.     int _day; // 日
31. };
33. void Test()
34. {
35.     Date d1(2022,1,13);
36.     d1.Print();
37.     const Date d2(2022,1,13);
38.     d2.Print();
39. }

复制代码

回答下列问题
1、const 对象可以调用非 const 成员函数吗
不可以，因为 const 对象的成员变量无法修改，this 指针的范例为 const type*
2、非 const 对象可以调用 const 成员函数吗
可以
3、const 成员函数内可以调用其它的非 const 成员函数吗
不可以
4、非 const 成员函数内可以调用其它的 const 成员函数吗
可以， const 成员函数不会修改成员变量，非 const 成员函数可能会修改，属于权限放大
七 取所在及 const 取所在操纵符重载

这两个默认成员函数一样平常不消重新定义 ，编译器默认会生成

1. class Date
2. {
3. public :
4.     Date* operator&()
5.     {
6.         return this;
7.     }
8.    
9.     const Date* operator&() const
10.     {
11.         return this;
12.     }
13.    
14. private :
15.     int _year; // 年
16.     int _month; // 月
17.     int _day; // 日
18. };

复制代码

这两个运算符一样平常不需要重载，使用编译器生成的默认取所在的重载即可。只有特殊情况，才需要重载，好比想让外部无法获取到该类对象所在时

1. class Date
2. {
3. public :
4.     Date* operator&()
5.     {
6.         return nullptr;
7.     }
8.    
9.     const Date* operator&() const
10.     {
11.         return nullptr;
12.     }
13.    
14. private :
15.     int _year; // 年
16.     int _month; // 月
17.     int _day; // 日
18. };

复制代码

八 日期类的实现

给出 Date 类如下头文件，实现 Date.cpp

1. class Date
2. {
3. public:
4.     // 获取某年某月的天数
5.     int GetMonthDay(int year, int month)
6.     {
7.         static int days[13] = { 0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };
8.         int day = days[month];
9.         if (month == 2
10.             && ((year % 4 == 0 && year % 100 != 0) || (year % 400 == 0)))
11.         {
12.             day += 1;
13.         }
14.         return day;
15.     }
17.     // 全缺省的构造函数
18.     Date(int year = 1900, int month = 1, int day = 1);
19.     // 拷贝构造函数
20.     // d2(d1)
21.     Date(const Date& d);
23.     // 赋值运算符重载
24.     // d2 = d3 -> d2.operator=(&d2, d3)
25.     const Date& operator=(const Date& d);
26.     // 析构函数
27.     ~Date();
28.     // 日期+=天数
29.     Date& operator+=(int day);
30.     // 日期+天数
31.     Date operator+(int day) const;
32.     // 日期-天数
33.     Date operator-(int day) const;
34.     // 日期-=天数
35.     Date& operator-=(int day);
36.     // 前置++
37.     Date& operator++();
38.     // 后置++
39.     Date operator++(int);
40.     // 后置--
41.     Date operator--(int);
42.     // 前置--
43.     Date& operator--();
45.     // >运算符重载
46.     bool operator>(const Date& d) const;
47.     // ==运算符重载
48.     bool operator==(const Date& d) const;
49.     // >=运算符重载
50.     bool operator >= (const Date& d) const;
51.     // <运算符重载
52.     bool operator < (const Date& d) const;
53.     // <=运算符重载
54.     bool operator <= (const Date& d) const;
55.     // !=运算符重载
56.     bool operator != (const Date& d) const;
57.     // 日期-日期 返回天数
58.     int operator-(const Date& d) const;
59. private:
60.     int _year;
61.     int _month;
62.     int _day;
63. };

复制代码

代码实现

1. #include "Date.h"
3. // 全缺省的构造函数
4. Date::Date(int year = 1900, int month = 1, int day = 1) {}
6. // 拷贝构造函数
7. // d2(d1)
8. Date::Date(const Date& d) {}
10. // 赋值运算符重载
11. // d2 = d3 -> d2.operator=(&d2, d3)
12. const Date& Date::operator=(const Date& d)
13. {
14.         _year = d._year;
15.         _month = d._month;
16.         _day = d._day;
17.         return *this;
18. }
20. // 析构函数
21. Date::~Date() {}
23. // 日期+=天数
24. Date& Date::operator+=(int day)
25. {
26.         if (day < 0) return *this -= day;
28.         _day += day;
30.         while(_day > GetMonthDay(_year,_month))
31.         {
32.                 _day -= GetMonthDay(_year, _month);
33.                 _month++;
35.                 if (_month == 13)
36.                 {
37.                         _year++;
38.                         _month = 1;
39.                 }
40.         }
41.         return *this;
42. }
44. // 日期-=天数
45. Date& Date::operator-=(int day)
46. {
47.         if (day < 0) return *this += -day;
49.         _day -= day;
51.         while (_day <= 0)
52.         {
53.                 _month--;
54.                 if (_month == 0)
55.                 {
56.                         _year--;
57.                         _month = 12;
58.                 }
59.                 _day += GetMonthDay(_year, _month);
60.         }
61.         return *this;
63. }
65. // 日期+天数
66. Date Date::operator+(int day) const
67. {
68.         Date ret(*this);
69.         ret += day;
70.         return ret;
71. }
73. // 日期-天数
74. Date Date::operator-(int day) const
75. {
76.         Date ret(*this);
77.         ret -= day;
78.         return ret;
79. }
81. // 前置++
82. Date& Date::operator++()
83. {
84.         *this += 1;
85.         return *this;
86. }
87. // 后置++
88. Date Date::operator++(int)
89. {
90.         Date ret(*this);
91.         ret += 1;
92.         return ret;
93. }
95. // 前置--
96. Date& Date::operator--()
97. {
98.         *this -= 1;
99.         return *this;
100. }
102. // 后置--
103. Date Date::operator--(int)
104. {
105.         Date ret(*this);
106.         ret -= 1;
107.         return ret;
108. }
110. // > 运算符重载
111. bool Date::operator>(const Date& d) const
112. {
113.         if (_year > d._year) return true;
114.         else if (_year < d._year) return false;
115.         else
116.         {
117.                 if (_month > d._month) return true;
118.                 else if (_month < d._month) return false;
119.                 else
120.                 {
121.                         if (_day > d._day) return true;
122.                         else if (_day < d._day) return false;
123.                 }
124.         }
126.         return false;
127. }
129. // == 运算符重载
130. bool Date::operator==(const Date& d) const
131. {
132.         return _year == d._year &&
133.                    _month == d._month &&
134.                    _day == d._year;
135. }
137. // < 运算符重载
138. bool Date::operator < (const Date& d) const
139. {
140.         if (_year < d._year) return true;
141.         else if (_year > d._year) return false;
142.         else
143.         {
144.                 if (_month < d._month) return true;
145.                 else if (_month > d._month) return false;
146.                 else
147.                 {
148.                         if (_day < d._day) return true;
149.                         else if (_day > d._day) return false;
150.                 }
151.         }
153.         return false;
154. }
156. // >=运算符重载
157. bool Date::operator >= (const Date& d) const
158. {
159.         if (*this < d) return false;
160.         else return true;
161. }
163. // <=运算符重载
164. bool Date::operator <= (const Date& d) const
165. {
166.         if (*this > d) return false;
167.         else return true;
168. }
169. // !=运算符重载
170. bool Date::operator != (const Date& d) const
171. {
172.         if (*this == d) return false;
173.         else return true;
174. }
176. // 日期-日期 返回天数
177. int Date::operator-(const Date& d) const
178. {
179.         int status = 1;
180.         Date max = *this;
181.         Date min = d;
183.         if (max < min)
184.         {
185.                 max = d;
186.                 min = *this;
187.                 status = -1;
188.         }
190.         int day = 0;
191.         while (min < max)
192.         {
193.                 ++min, ++day;
194.         }
195.         return status * day;
196. }

复制代码

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。