• 类与对象(中)

    文章目录

    前言

    本小节我们来讲一讲关于类中的六个默认成员函数，其实前四个很重要，需要大家着重理解，后面两个大家了解即可。
    构造函数
    析构函数
    拷贝构造函数
    赋值操作符重载
    取地址操作符重载
    const取地址操作符重载

    正文开始

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

    如果一个类中什么成员都没有，简称为空类。空类中什么都没有吗？并不是的，任何一个类在我们不写的情
    况下，都会自动生成下面6个默认成员函数
    class Date {};
    在这里插入图片描述

    二、构造函数

    2.1 概念

    对于以下的日期类：

    class Date
{ 
public:
 void SetDate(int year, int month, int day)
 {
	 _year = year;
	 _month = month;
	 _day = day;
 }
 
 void Display()
 {
 	cout <<_year<< "-" <<_month << "-"<< _day <<endl;
 }
private:
	 int _year;
	 int _month;
	 int _day;
};
int main()
{
	 Date d1,d2;
	 d1.SetDate(2018,5,1);
	 d1.Display();
	 
	 Date d2;
	 d2.SetDate(2018,7,1);
	 d2.Display();
	 return 0;
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30

    对于Date类，可以通过SetDate公有的方法给对象设置内容，但是如果每次创建对象都调用该方法设置信
    息，未免有点麻烦，那能否在对象创建时，就将信息设置进去呢？
    构造函数是一个特殊的成员函数，名字与类名相同,创建类类型对象时由编译器自动调用，保证每个数据成员
    都有 一个合适的初始值，并且在对象的生命周期内只调用一次。

    2.2 特性

    构造函数是特殊的成员函数，需要注意的是，构造函数的虽然名称叫构造，但是需要注意的是构造函数的主
    要任务并不是开空间创建对象，而是初始化对象。
    其特征如下：

    1. 函数名与类名相同。
    2. 无返回值。
    3. 对象实例化时编译器自动调用对应的构造函数。
    4. 构造函数可以重载。
    class Date
{ 
public :
 // 1.无参构造函数
 	Date ()
 	{}
 
 // 2.带参构造函数
	 Date (int year, int month , int day )
	 {
		 _year = year ;
		 _month = month ;
		 _day = day ;
	 }
private :
	 int _year ;
	 int _month ;
	 int _day ;
};
void TestDate()
{
	 Date d1; // 调用无参构造函数
	 Date d2 (2015, 1, 1); // 调用带参的构造函数
	 
	 // 注意：如果通过无参构造函数创建对象时，对象后面不用跟括号，否则就成了函数声明
	 // 以下代码的函数：声明了d3函数，该函数无参，返回一个日期类型的对象
	 Date d3(); 
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    1. 如果类中没有显式定义构造函数，则C++编译器会自动生成一个无参的默认构造函数，一旦用户显式定
      义编译器将不再生成
    class Date
{
public:
 /*
 // 如果用户显式定义了构造函数，编译器将不再生成
	 Date (int year, int month, int day)
	 {
		 _year = year;
		 _month = month;
		 _day = day;
	 }
 */
private:
 int _year;
 int _month;
 int _day;
};
void Test()
{
	 // 没有定义构造函数，对象也可以创建成功，因此此处调用的是编译器生成的默认构造函数
	  Date d;
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    1. 无参的构造函数和全缺省的构造函数都称为默认构造函数，并且默认构造函数只能有一个。注意：无参
      构造函数、全缺省构造函数、我们没写编译器默认生成的构造函数，都可以认为是默认成员函数。
    // 默认构造函数
class Date
{ 
public:
	 Date()
	 {
		 _year = 1900 ;
		 _month = 1 ;
		 _day = 1;
	 }
 
	 Date (int year = 1900, int month = 1, int day = 1)
	 {
		 _year = year;
		 _month = month;
		 _day = day;
	 }
private :
 int _year ;
 int _month ;
 int _day ;
};
// 以下测试函数能通过编译吗？
void Test()
{
 	Date d1;
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    1. 关于编译器生成的默认成员函数，很多童鞋会有疑惑：在我们不实现构造函数的情况下，编译器会生成
      默认的构造函数。但是看起来默认构造函数又没什么用？d对象调用了编译器生成的默认构造函数，但
      是d对象year/month/_day，依旧是随机值。也就说在这里编译器生成的默认构造函数并没有什么卵
      用？？
      解答：C++把类型分成内置类型(基本类型)和自定义类型。内置类型就是语法已经定义好的类型：如
      int/char…，自定义类型就是我们使用class/struct/union自己定义的类型，看看下面的程序，就会发现
      编译器生成默认的构造函数会对自定类型成员_t调用的它的默认成员函数
    class Time
{
public:
	 Time()
	 {
		 cout << "Time()" << endl;
		 _hour = 0;
		 _minute = 0;
		 _second = 0;
	 }
private:
 int _hour;
 int _minute;
 int _second;
};
class Date
{
private:
 // 基本类型(内置类型)
 int _year;
 int _month;
 int _day;
 // 自定义类型
 Time _t;
};
int main()
{
	 Date d;
	 return 0;
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30

    在这里插入图片描述
    8. 成员变量的命名风格

    // 我们看看这个函数，是不是很僵硬？
class Date
{
public:
	 Date(int year)
	 {
		 // 这里的year到底是成员变量，还是函数形参？
		 year = year;
	 }
private:
 int year;
};
// 所以我们一般都建议这样
class Date
{
public:
	 Date(int year)
	 {
	 	_year = year;
	 }
 private:
 int _year;
};
// 或者这样。
class Date
{
public:
	 Date(int year)
	 {
	 	m_year = year;
	 }
private:
 int m_year;
};
// 其他方式也可以的，主要看公司要求。一般都是加个前缀或者后缀标识区分就行。

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35

    三、析构函数

    3.1 概念

    前面通过构造函数的学习，我们知道一个对象时怎么来的，那一个对象又是怎么没呢的？
    析构函数：与构造函数功能相反，析构函数不是完成对象的销毁，局部对象销毁工作是由编译器完成的。而
    对象在销毁时会自动调用析构函数，完成类的一些资源清理工作。

    3.2 特性

    析构函数是特殊的成员函数。
    其特征如下：

    1. 析构函数名是在类名前加上字符 ~。
    2. 无参数无返回值。
    3. 一个类有且只有一个析构函数。若未显式定义，系统会自动生成默认的析构函数。
    4. 对象生命周期结束时，C++编译系统系统自动调用析构函数。
    typedef int DataType;
class SeqList
{ 
public :
	 SeqList (int capacity = 10)
	 {
		 _pData = (DataType*)malloc(capacity * sizeof(DataType));
		 assert(_pData);
		 
		 _size = 0;
		 _capacity = capacity;
	 }
 
 	~SeqList()
	{
		 if (_pData)
		 {
		 free(_pData ); // 释放堆上的空间
		 _pData = NULL; // 将指针置为空
		 _capacity = 0;
		 _size = 0;
		 }
	}
 
private :
 int* _pData ;
 size_t _size;
 size_t _capacity;
};

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    1. 关于编译器自动生成的析构函数，是否会完成一些事情呢？下面的程序我们会看到，编译器生成的默认
      析构函数，对会自定类型成员调用它的析构函数。
    class String
{
public:
	 String(const char* str = "jack")
	 {
		 _str = (char*)malloc(strlen(str) + 1);
		 strcpy(_str, str);
	 }
	 ~String()
	 {
		 cout << "~String()" << endl;
		 free(_str);
	 }
private:
 char* _str;
};
class Person
{
private:
 String _name;
 int _age;
};
int main()
{
	 Person p;
	 return 0;
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27

    四、拷贝构造函数

    4.1 概念

    在现实生活中，可能存在一个与你一样的自己，我们称其为双胞胎。
    那在创建对象时，可否创建一个与一个对象一某一样的新对象呢？
    构造函数：只有单个形参，该形参是对本类类型对象的引用(一般常用const修饰)，在用已存在的类类型对象
    创建新对象时由编译器自动调用

    4.2 特征

    类与对象练习.pdf
    pdf 0星 超过10%的资源 392KB
    下载

    拷贝构造函数也是特殊的成员函数，其特征如下：

    1. 拷贝构造函数是构造函数的一个重载形式。
    2. 拷贝构造函数的参数只有一个且必须使用引用传参，使用传值方式会引发无穷递归调用。
    class Date
{
public:
	 Date(int year = 1900, int month = 1, int day = 1)
	 {
		 _year = year;
		 _month = month;
		 _day = day;
	 }
	 Date(const Date& d)
	 {
		 _year = d._year;
		 _month = d._month;
		 _day = d._day;
	 }
private:
 int _year;
 int _month;
 int _day;
};
int main()
{
	 Date d1;
	 Date d2(d1);
	 return 0;
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26

    在这里插入图片描述
    3. 若未显示定义，系统生成默认的拷贝构造函数。 默认的拷贝构造函数对象按内存存储按字节序完成拷
    贝，这种拷贝我们叫做浅拷贝，或者值拷贝。

    class Date
{
public:
	 Date(int year = 1900, int month = 1, int day = 1)
	 {
		 _year = year;
		 _month = month;
		 _day = day;
	 }
private:
 int _year;
 int _month;
 int _day;
};
int main()
{
	 Date d1;
	  // 这里d2调用的默认拷贝构造完成拷贝，d2和d1的值也是一样的。
	 Date d2(d1);
	 return 0; 
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    1. 那么编译器生成的默认拷贝构造函数已经可以完成字节序的值拷贝了，我们还需要自己实现吗？当然像
      日期类这样的类是没必要的。那么下面的类呢？验证一下试试？
    // 这里会发现下面的程序会崩溃掉？这里就需要我们以后讲的深拷贝去解决。
class String
{
public:
	 String(const char* str = "jack")
	 {
		 _str = (char*)malloc(strlen(str) + 1);
		 strcpy(_str, str);
	 }
	 ~String()
	 {
		 cout << "~String()" << endl;
		 free(_str);
	 }
private:
 char* _str;
};
int main()
{
 	String s1("hello");
 	String s2(s1);
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22

    五、赋值运算符重载

    5.1 运算符重载

    C++为了增强代码的可读性引入了运算符重载，运算符重载是具有特殊函数名的函数，也具有其返回值类
    型，函数名字以及参数列表，其返回值类型与参数列表与普通的函数类似。
    函数名字为：关键字operator后面接需要重载的运算符符号。
    函数原型：返回值类型 operator操作符(参数列表)
    注意：
    不能通过连接其他符号来创建新的操作符：比如operator@
    重载操作符必须有一个类类型或者枚举类型的操作数
    用于内置类型的操作符，其含义不能改变，例如：内置的整型+，不 能改变其含义
    作为类成员的重载函数时，其形参看起来比操作数数目少1成员函数的
    操作符有一个默认的形参this，限定为第一个形参
    .* 、:: 、sizeof 、?: 、. 注意以上5个运算符不能重载。这个经常在笔试选择题中出现。

    // 全局的operator==
class Date
{ 
public:
	 Date(int year = 1900, int month = 1, int day = 1)
	 {
		 _year = year;
		 _month = month;
		 _day = day;
	 } 
//private:
 int _year;
 int _month;
 int _day;
};
// 这里会发现运算符重载成全局的就需要成员变量是共有的，那么问题来了，封装性如何保证？
// 这里其实可以用我们后面学习的友元解决，或者干脆重载成成员函数。
bool operator==(const Date& d1, const Date& d2) {
	 return d1._year == d2._year;
	 && d1._month == d2._month
	 && d1._day == d2._day;
 }
void Test ()
{
	 Date d1(2018, 9, 26);
	 Date d2(2018, 9, 27);
	 cout<<(d1 == d2)<<endl;
}


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    class Date
{ 
public:
	 Date(int year = 1900, int month = 1, int day = 1)
	 {
		 _year = year;
		 _month = month;
		 _day = day;
	 }
 
 // bool operator==(Date* this, const Date& d2)
 // 这里需要注意的是，左操作数是this指向的调用函数的对象
 bool operator==(const Date& d2)
 {
	 return _year == d2._year;
	 && _month == d2._month
	 && _day == d2._day;
 }
private:
 int _year;
 int _month;
 int _day;
};
void Test ()
{
	 Date d1(2018, 9, 26);
	 Date d2(2018, 9, 27);
	 cout<<(d1 == d2)<<endl; 
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29

    5.2 赋值运算符重载

    class Date
{ 
public :
	 Date(int year = 1900, int month = 1, int day = 1)
	 {
		 _year = year;
		 _month = month;
		 _day = day;
	 }
 
	 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;
		 }
	 }
private:
 int _year ;
 int _month ;
 int _day ;
};

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31

    赋值运算符主要有四点：

    1. 参数类型
    2. 返回值
    3. 检测是否自己给自己赋值
    4. 返回*this
    5. 一个类如果没有显式定义赋值运算符重载，编译器也会生成一个，完成对象按字节序的值拷贝。
    class Date
{
public:
	 Date(int year = 1900, int month = 1, int day = 1)
	 {
		 _year = year;
		 _month = month;
		 _day = day;
	 }
private:
 int _year;
 int _month;
 int _day;
};
int main()
{
	 Date d1;
	 Date d2(2018，10， 1);
	 
	 // 这里d1调用的编译器生成operator=完成拷贝，d2和d1的值也是一样的。
	 d1 = d2；
	 return 0;
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23

    那么编译器生成的默认赋值重载函数已经可以完成字节序的值拷贝了，我们还需要自己实现吗？当然像
    日期类这样的类是没必要的。那么下面的类呢？验证一下试试？

    // 这里会发现下面的程序会崩溃掉？这里就需要我们以后讲的深拷贝去解决。
class String
{
public:
	 String(const char* str = "")
	 {
		 _str = (char*)malloc(strlen(str) + 1);
		 strcpy(_str, str);
	 }
	 ~String()
	 {
		 cout << "~String()" << endl;
		 free(_str);
		 }
		 private:
		 char* _str;
	};
int main()
{
	 String s1("hello");
	 String s2("world");
	 
	 s1 = s2;
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24

    六、日期类的实现

    编写C++程序用类与对象的思想求一个有关矩阵的算法
    text/x-c++ 5星 超过95%的资源 1KB
    下载

    Date.h

    #pragma once
#pragma once
#include
#include
using std::cout;
using std::cin;
using std::endl;

class Date
{
public:
	Date(int year = 0, int month = 1, int day = 1);
	void Print();
	//析构，拷贝构造，赋值重载，可以不写，默认生成的就够用了
	//想Stack才需要自己写这三个

	//d+100
	Date& operator+=(int day);
	Date& operator-=(int day);
	Date operator+(int day);
	Date operator-(int day);
	bool operator>(const Date& d);
	bool operator<(const Date& d);
	bool operator==(const Date& d);
	bool operator>=(const Date& d);
	bool operator<=(const Date& d);
	bool operator!=(const Date& d);


	//++d ->d.operator++(&d)
	Date& operator++();
	//d++ ->d.operator++(&d,0)
	//int参数不需要给实参，因为没用，它的作用是为了和前置++构成函数重载
	Date operator++(int);
	Date& operator--();
	Date operator--(int);
	int operator-(const Date& d);



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

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45

    Date.cpp

    #define _CRT_SECURE_NO_WARNINGS
#include"Date.h"

inline int GetMonthDay(int year, int month)
{
	static int DayArray[13] = { 0,31,28,31,30,31,30,31,31,30,31,30,31 };//存放平年每个月的天数
	int day = DayArray[month];
	if (month == 2 && ((year % 4 == 0 && year % 100 != 0) || year % 400 == 0))
	{
		day = 29;
	}
	return day;
}


Date::Date(int year, int month, int day)
{
	//检查日期的合法性
	if (year >= 0
		&& month > 0 && month < 13
		&& day>0 && day <= GetMonthDay(year, month))
	{
		_year = year;
		_month = month;
		_day = day;
	}
	else
	{
		//严格来说抛异常更好
		cout << "非法日期" << endl;
		cout << year << "年" << month << "月" << day << "日" << endl;
		//assert(false);
		//exif(-1);
	}


}
void Date::Print()
{
	cout << _year << "年" << _month << "月" << _day << "日" << endl;
}

//d+100
//Date Date::operator+(int day)
//{
//	Date ret(*this);
//	ret._day += day;
//	//天数不合法，不断进位，让他合法
//	while (ret._day > GetMonthDay(ret._year, ret._month))
//	{
//		ret._day -= GetMonthDay(ret._year, ret._month);
//		ret._month++;
//		if (ret._month > 12)
//		{
//			ret._month = 1;
//			ret._year++;
//		}
//	}
//	return *this;
//}

Date& Date::operator+=(int day)
{
	if (day < 0)
	{
		*this -= (-day);
	}
	else
	{
		_day += day;
		//天数不合法，不断进位，让他合法
		while (_day > GetMonthDay(_year, _month))
		{
			_day -= GetMonthDay(_year, _month);
			_month++;
			if (_month > 12)
			{
				_month = 1;
				_year++;
			}
		}
	}
	return *this;
}

//d+100
Date Date::operator+(int day)
{
	Date ret(*this);
	//复用
	ret += day;
	return ret;
}

Date& Date::operator-=(int day)
{
	if (day > 0)
	{
		_day -= day;
		while (_day <= 0)
		{
			_day += GetMonthDay(_year, _month);
			_month--;
			if (_month < 1)
			{
				_month += 12;
				_year--;
			}
		}
	}
	else
	{
		//复用调上面的函数
		*this += (-day);
	}
	return *this;
}
Date Date::operator-(int day)
{
	Date ret(*this);
	ret -= day;
	return ret;
}

//++d ->d.operator++(&d)
Date& Date::operator++()
{
	*this += 1;
	return *this;
}
//d++ ->d.operator++(&d,0)
//int参数不需要给实参，因为没用，它的作用是为了和前置++构成函数重载
Date Date::operator++(int)
{
	Date ret = *this;
	(*this) += 1;
	return ret;
}
Date& Date::operator--()
{
	*this -= 1;
	return *this;
}
Date Date::operator--(int)
{
	Date ret = *this;
	(*this) -= 1;
	return ret;
}
bool Date::operator>(const Date& d)
{
	if (_year > d._year)
	{
		return true;
	}
	else if (_year == d._year)
	{
		if (_month > d._month)
		{
			return true;
		}
		else if (_month == d._month)
		{
			if (_day > d._day)
			{
				return true;
			}
		}
	}
	return false;
}
bool Date::operator==(const Date& d)
{
	if (_year == d._year && _month == d._month && _day == d._day)
		return true;
	return false;
}

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

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

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

int Date::operator-(const Date& d)
{
	//效率差别不大的情况下，尽量选择写可读性强，简单的程序
	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;
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55
    • 56
    • 57
    • 58
    • 59
    • 60
    • 61
    • 62
    • 63
    • 64
    • 65
    • 66
    • 67
    • 68
    • 69
    • 70
    • 71
    • 72
    • 73
    • 74
    • 75
    • 76
    • 77
    • 78
    • 79
    • 80
    • 81
    • 82
    • 83
    • 84
    • 85
    • 86
    • 87
    • 88
    • 89
    • 90
    • 91
    • 92
    • 93
    • 94
    • 95
    • 96
    • 97
    • 98
    • 99
    • 100
    • 101
    • 102
    • 103
    • 104
    • 105
    • 106
    • 107
    • 108
    • 109
    • 110
    • 111
    • 112
    • 113
    • 114
    • 115
    • 116
    • 117
    • 118
    • 119
    • 120
    • 121
    • 122
    • 123
    • 124
    • 125
    • 126
    • 127
    • 128
    • 129
    • 130
    • 131
    • 132
    • 133
    • 134
    • 135
    • 136
    • 137
    • 138
    • 139
    • 140
    • 141
    • 142
    • 143
    • 144
    • 145
    • 146
    • 147
    • 148
    • 149
    • 150
    • 151
    • 152
    • 153
    • 154
    • 155
    • 156
    • 157
    • 158
    • 159
    • 160
    • 161
    • 162
    • 163
    • 164
    • 165
    • 166
    • 167
    • 168
    • 169
    • 170
    • 171
    • 172
    • 173
    • 174
    • 175
    • 176
    • 177
    • 178
    • 179
    • 180
    • 181
    • 182
    • 183
    • 184
    • 185
    • 186
    • 187
    • 188
    • 189
    • 190
    • 191
    • 192
    • 193
    • 194
    • 195
    • 196
    • 197
    • 198
    • 199
    • 200
    • 201
    • 202
    • 203
    • 204
    • 205
    • 206
    • 207
    • 208
    • 209
    • 210
    • 211
    • 212
    • 213
    • 214
    • 215
    • 216
    • 217

    test.cpp

    #define _CRT_SECURE_NO_WARNINGS
#include"Date.h"
void Test1()
{
	Date d1(2022, 7, 27);
	d1.Print();
	/*Date d2(2022, 0, 0);
	d2.Print();
	Date d3(2023, 2, 29);
	d3.Print();*/
	d1 = d1 + 1000;
	d1.Print();
}
void Test2()
{
	Date d1(2022, 7, 27);
	d1 += 10;
	d1.Print();
	d1 += 10;
	d1.Print();
	d1 += 10;
	d1.Print();

	d1 + 10;
	d1.Print();
	d1 + 10;
	d1.Print();
	d1 + 10;
	d1.Print();

}
void Test3()
{
	Date d1(2022, 7, 27);
	//前置++和后置++都完成了++，不同的地方在于返回值不一样
	//因为他们的运算符是一样的，函数名就是一样的
	//为了区分，对后置++做了特殊处理，形成函数重载
	d1++;
	d1.Print();
	++d1;
	d1.Print();

}
void Test4()
{
	Date d1(2022, 5, 27);
	Date d2(2022, 12, 31);
	cout << (d2 - d1) << endl;
	cout << (d1 - d2) << endl;

}
int main()
{
	Test4();
	return 0;
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55
    • 56

    七、const成员

    7.1 const修饰类的成员函数

    将const修饰的类成员函数称之为const成员函数，const修饰类成员函数，实际修饰该成员函数隐含的this
    指针，表明在该成员函数中不能对类的任何成员进行修改。
    在这里插入图片描述
    我们来看看下面的代码

    class Date
{ 
public :
 void Display ()
 {
	 cout<<"Display ()" <<endl;
	 cout<<"year:" <<_year<< endl;
	 cout<<"month:" <<_month<< endl;
	 cout<<"day:" <<_day<< endl<<endl ;
 }
 void Display () const
 {
	 cout<<"Display () const" <<endl;
	 cout<<"year:" <<_year<< endl;
	 cout<<"month:" <<_month<< endl;
	 cout<<"day:" <<_day<< endl<<endl;
 }
private :
 int _year ; // 年
 int _month ; // 月
 int _day ; // 日
};
void Test ()
{
	 Date d1 ;
	 d1.Display ();
	 
	 const Date d2;
	 d2.Display ();
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30

    请思考下面的几个问题：

    1. const对象可以调用非const成员函数吗？
      不可以，权限的放大
    2. 非const对象可以调用const成员函数吗？
      可以，权限的缩小
    3. const成员函数内可以调用其它的非const成员函数吗？
      不可以，权限的放大
    4. 非const成员函数内可以调用其它的const成员函数吗？
      可以，权限的缩小

    八、取地址及const取地址操作符重载

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

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

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17

    这两个运算符一般不需要重载，使用编译器生成的默认取地址的重载即可，只有特殊情况，才需要重载，比
    如想让别人获取到指定的内容！(可以return nullptr让别人访问不到你的地址)。

    总结

    提示：这里对文章进行总结：
    例如：以上就是今天要讲的内容，本文仅仅简单介绍了类的六个默认成员函数和一个Date日期类的实现，文章内容不多，但是需要理解的地方很多，不会的地方可以反复阅读+理解！！
    希望大家三连支持哦！！

  • 相关阅读:
    SpringBoot一：概述
    JVM学习-Class文件结构
    常见的网络威胁及解决办法
    【Python小项目之Tkinter应用】随机点名/抽奖工具大优化：实现背景图与其他组件自适应窗口大小变化并保持相对位置和比例不变
    猿创征文｜聊一聊我在字节跳动做项目质量改进的经验
    小程序的开发与应用|软件定制开发|APP网站搭建
    服务器数据恢复-linux+raid+VMwave ESX数据恢复案例
    第七章 贝叶斯分类器（下）
    应用程序无法正常启动0xc000007b的解决策略，多种解决方法分享
    ChatGPT 的 Text Completion
  • 原文地址：https://blog.csdn.net/m0_61560468/article/details/126038242