C++类和对象（中）

₯㎕星空&繁华

已于 2024-08-10 22:08:36 修改

阅读量647

点赞数 21

分类专栏： C++ 文章标签： c++ 笔记经验分享

于 2024-08-09 23:35:09 首次发布

本文链接：https://blog.csdn.net/m0_73936730/article/details/137093009

版权

C++ 专栏收录该内容

5 篇文章 1 订阅

订阅专栏

7.2.2赋值运算符只能重载成类的成员函数不能重载成全局函数

1.启语

干货满满！

2.this指针

2.1this指针的引出

我们先来定义一个日期类 Date

class Date
{ 
public:
 void Init(int year, int month, int day)
 {
 _year = year;
 _month = month;
 _day = day;
 }
 void Print()
 {
 cout <<_year<< "-" <<_month << "-"<< _day <<endl;
 }
private:
 int _year;     // 年
 int _month;    // 月
 int _day;      // 日
};
int main()
{
 Date d1, d2;
 d1.Init(2022,1,11);
 d2.Init(2022, 1, 12);
 d1.Print();
 d2.Print();
 return 0;
}

对于上述类，有这样的一个问题： Date类中有 Init 与 Print 两个成员函数，函数体中没有关于不同对象的区分，那当d1调用 Init 函数时，该函数是如何知道应该设置d1对象，而不是设置d2对象呢？ C++中通过引入this指针解决该问题，即：C++编译器给每个“非静态的成员函数“增加了一个隐藏的指针参数，让该指针指向当前对象(函数运行时调用该函数的对象)，在函数体中所有“成员变量” 的操作，都是通过该指针去访问。只不过所有的操作对用户是透明的，即用户不需要来传递，编译器自动完成。

2.2this指针的特性

1. this指针的类型：类类型* const，即成员函数中，不能给this指针赋值 ，可以改变this指向的内容。

2. 只能在“成员函数”的内部使用

3. this指针本质上是“成员函数”的形参，当对象调用成员函数时，将对象地址作为实参传递给 this形参。所以对象中不存储this指针。

4. this指针是“成员函数”第一个隐含的指针形参，一般情况由编译器通过ecx寄存器自动传递，不需要用户传递。

我们讲点值得注意的，先看看第一点this指针是*const的内容：

再看看我们之前的代码：

符合第一点

1. this指针的类型：类类型* const，即成员函数中，不能给this指针赋值 ，可以改变this指向的内容。

第二点没啥好说的我们直接说第三点：

3. this指针本质上是“成员函数”的形参，当对象调用成员函数时，将对象地址作为实参传递给 this形参。所以对象中不存储this指针。

这个在之前引用的时候可以看得出来，我们主要是为了提一嘴虽this指针是隐含的，但是成员函数的形参永远是N+1个。

我们看看第四点：

4. this指针是“成员函数”第一个隐含的指针形参，一般情况由编译器通过ecx寄存器自动传递，不需要用户传递。

通俗来讲就是编译器不想让你把活给抢了。

我们再来看两个代码再深入了解：

#include<iostream>
using namespace std;

class A
{
public:
	void PrintA()
	{
		cout << "Print()" << endl;
	}
private:
	int _a;
};
int main()
{
	A* p = nullptr;
	p->PrintA();
	return 0;
}

下面程序编译运行结果是？ A、编译报错 B、运行崩溃 C、正常运行

答案是B

这里变量p是一个类的指针，把它置为nullptr，然后把它当做指针，赋给this指针，在语法上并没有错误所以不会编译出错，然后访问函数Print，p指向的空间没有Print（Print不存在对象里面），他并没有对this指针所指向的内容进行解引用（访问）

同理如果将p-> PrintA()换成（*p).PrintA()也是一样正常运行。它们都不在对象里面，都需要调用函数。

我们看看第二个

class A
{ 
public:
    void PrintA() 
   {
        cout<<_a<<endl;
   }
private:
 int _a;
};
int main()
{
    A* p = nullptr;
    p->PrintA();
    return 0;
}

下面程序编译运行结果又是？ A、编译报错 B、运行崩溃 C、正常运行

答案是B

跟第一题不一样的是，它不但把nullptr作为形参传递给this指针，把this变成空指针，并且解引用了空指针，所以编译器会进行报错。

2,3this指针的存放

了解完this指针的特性，你有没有好奇this指针到底存在哪里呢？

假设它可能存在这些地方，我们来看看：

a、堆 b、栈 c、静态区 d、常量区 e、对象里面

A.堆

只有malloc这样才能存放在堆中，所以我们直接排除A。

B.栈

正确，因为他是一个形参（有些编译比如vs可能会用寄存器存储

汇编结果：

C.常量区

我们可以看到i、j、p都是在里，但是* P 不在，而是在常量区。

D.对象里面

我们的类和对象上之前算空间字节的时候，我们算的sizeof是12字节
class Date
{
public:
	void Init(int year, int month, int day)
	{
		_year = year;
		_month = month;
		_day = day;
	}
 
	void Print()
	{
		cout << _year << "/" << _month << "/" << _day << endl;
	}
	//private:
	int _year;   
	int _month;
	int _day;
};
 
int main()
{
	Date d1;
	Date d2;
	d1._year;
	d2._year;
 
	d1.Print();
	d2.Print();
 
	
	return 0;
}
这里this指针不占字节，所以说明它不在对象里面。

3.类的6个默认成员函数

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

但是，空类中真的什么都没有吗？并不是，任何类在什么都不写时，编译器会自动生成以下6个默认成员函数。

默认成员函数：用户没有显式实现，编译器会生成的成员函数称为默认成员函数。

class Date {};

4.构造函数

4.1概念

对于以下 Date 类：

class Date
{
public:
 void Init(int year, int month, int day)
 {

 _year = year;
 _month = month;
 _day = day;
 }
 void Print()
 {
 cout << _year << "-" << _month << "-" << _day << endl;
 }
private:
 int _year;
 int _month;
 int _day;
};
int main()
{
 Date d1;
 d1.Init(2022, 7, 5);
 d1.Print();
 Date d2;
 d2.Init(2022, 7, 6);
 d2.Print();
 return 0;
}

对于Date类，可以通过 Init 公有方法给对象设置日期，但如果每次创建对象时都调用该方法设置信息，未免有点麻烦，那能否在对象创建时，就将信息设置进去呢？

构造函数是一个特殊的成员函数，名字与类名相同,创建类类型对象时由编译器自动调用，以保证每个数据成员都有一个合适的初始值，并且在对象整个生命周期内只调用一次。

4.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 函数，该函数无参，返回一个日期类型的对象

// warning C4930: “Date d3(void)”: 未调用原型函数 ( 是否是有意用变量定义的 ?)

Date d3 ();

}

5. 如果类中没有显示定义构造函数，则C++编译器会自动生成一个无参的默认构造函数，一旦用户显式定义编译器将不再生成。

	class Date
{
public:
	
	// 如果用户显式定义了构造函数，编译器将不再生成
	Date(int year, int month, int day)
	{
	_year = year;
	_month = month;
	_day = day;
	}
	

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

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

int main()
{
	// 将Date类中构造函数屏蔽后，代码可以通过编译，因为编译器生成了一个无参的默认构造函数
		// 将Date类中构造函数放开，代码编译失败，因为一旦显式定义任何构造函数，编译器将不再
	
		// 无参构造函数，放开后报错：error C2512: “Date”: 没有合适的默认构造函数可用
		Date d1;
	return 0;
}

6.关于编译器生成的默认成员函数，很多童鞋会有疑惑：不实现构造函数的情况下，编译器会

生成默认的构造函数。但是看起来默认构造函数又没什么用？对象调用了编译器生成的默

认构造函数，但是 d对象_year/_month/_day ，依旧是随机值。也就说在这里 编译器生成的

默认构造函数并没有什么用？

解答：

C++把类型分成内置类型(基本类型)和自定义类型。

内置类型就是语言提供的数据类型，如：int/char/double指针等。

自定义类型就是我们使用class/struct/union等自己定义的类型。

默认生成的构造函数，对于内置类型不做处理，自定义类型回去调用他的默认构造。

如果我们没写任何一个构造函数，编译器才会自动生成的，如果我们写了就不会生成了

我们举个实例

class A
	{
	public:
		A()
		{
			cout << "A()" << endl;
			_a = 0;
		}
	private:
		int _a;
	};
	
	class Date
	{
	public:
		void Print()
		{
			cout << _year << "-" << _month << "-" << _day << endl;
		}
	
	private:
	
		int _year ;
		int _month ;
		int _day;
	
		A _aa;
	};
	
	
	int main()
	{
		
		Date d1;
		d1.Print();
		return 0;
	}

C++11 委员会对这个语法进行打补丁, 在声明的位置给缺省值：

所以分析一个类型成员和初始化需求

需要写构造函数我们就自己写；不需要时就用编译器自己生成的

结论：绝大多数场景下面都需要自己实现构造函数

7.无参的构造函数和全缺省的构造函数都称为默认构造函数，并且默认构造函数只能有一个。

注意：无参构造函数、全缺省构造函数、我们没写编译器默认生成的构造函数，都可以认为

是默认构造函数。

我们看个代码

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;
}

5.析构函数

5.1概念

通过前面构造函数的学习，我们知道一个对象是怎么来的，那一个对象又是怎么没呢的？

析构函数：与构造函数功能相反，析构函数不是完成对对象本身的销毁，局部对象销毁工作是由编译器完成的。而对象在销毁时会自动调用析构函数，完成对象中资源的清理工作。

5.2特性

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

1. 析构函数名是在类名前加上字符 ~。

2. 无参数无返回值类型。

3. 一个类只能有一个析构函数。若未显式定义，系统会自动生成默认的析构函数。注意：析构函数不能重载

4. 对象生命周期结束时，C++编译系统系统自动调用析构函数。

我们来看最重要的第四点

4. 对象生命周期结束时，C++编译系统系统自动调用析构函数。

class Date
{
public:
	Date()
	{
		_year = 1;
		_month = 1;
		_day = 1;
	}

	Date(int year, int month, int day)
	{
		_year = year;
		_month = month;
		_day = day;
	}

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

	~Date()
	{
		cout << this << endl;
		cout << "~Date()" << endl;
	}

private:

	int _year = 1;
	int _month = 1;
	int _day;
};

void func()
{
	Date d2;
}

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

同时我们也可以看出来析构函数符合栈的后进先出，我们再来看看：

class Date
{
public:
	Date(int year = 1)
	{
		_year = year;
	}

	~Date()
	{
		cout << "~Date()->"<<_year<< endl;
	}

private:
	// 基本类型(内置类型)
	int _year;
	int _month;
	int _day;
};



void func()
{
	Date d3(3);
	static Date d4(4);
}

Date d5(5);
static Date d7(7);
Date d6(6);
static Date d8(8);


int main()
{
	Date d1(1);
	Date d2(2);
	func();

	return 0;
}

局部对象（后定义先析构） -》局部的静态 -》全局对象（后定义先析构）

默认生成的析构函数跟构造函数类似

内置类型不做处理，自定义类型的成员去调用他的析构

6. 拷贝构造函数

拷贝构造函数 ： 只有单个形参 ，该形参是对本 类类型对象的引用 ( 一般常用 const 修饰 ) ，在用 已存在的类类型对象创建新对象时由编译器自动调用。

6.1特性

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

1. 拷贝构造函数是构造函数的一个重载形式。

2. 拷贝构造函数的参数只有一个且必须是类类型对象的引用，使用传值方式编译器直接报错，因为会引发无穷递归调用。

3. 若未显式定义，编译器会生成默认的拷贝构造函数。 默认的拷贝构造函数对象按内存存储按字节序完成拷贝，这种拷贝叫做浅拷贝，或者值拷贝。

我们来看这段代码：

class Date
{
public:
	Date(int year = 1, 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;
	}

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

private:
	
	int _year;
	int _month;
	int _day;


};


void func1(Date d)
{

}

void func2(Date& rd)
{

}

int main()
{
	Date d1(2024, 1, 28);
	
	func1(d1);
	func2(d1);

	return 0;
}

我们来看看运行func1()的运行

上面的图片我我们可以看出，d1的类型先是Date &d ，如果是Date，它是怎么运行的呢？

我们看下图：

如果当我们将const Date &d（const 是为了防止引用内容被修改）改成Date d会发生什么呢？

原因如下：

形成了一个无限递归。

下面讲如何避免这种情况了，引用可以解决，&rd是d1的别名直接完成调用。

下面我们试试将Date(const Date& d)注释掉看看是否会生成默认构造函数。

打印成功，是会生成默认构造函数的，说明在拷贝函数中会对内置类型进行处理。

3.若未显式定义，编译器会生成默认的拷贝构造函数。 默认的拷贝构造函数对象按内存存储按字节序完成拷贝，这种拷贝叫做浅拷贝，或者值拷贝。

class Time
{
public:
 Time()
 {
 _hour = 1;
 _minute = 1;
 _second = 1;

 }
 Time(const Time& t)
 {
 _hour = t._hour;
 _minute = t._minute;
 _second = t._second;
 cout << "Time::Time(const Time&)" << endl;
 }
private:
 int _hour;
 int _minute;
 int _second;
};
class Date
{
private:
 // 基本类型(内置类型)
 int _year = 1970;
 int _month = 1;
 int _day = 1;
 // 自定义类型
 Time _t;
};
int main()
{
 Date d1;
   
 Date d2(d1);
 return 0;
}

用已经存在的d1拷贝构造d2，此处会调用Date类的拷贝构造函数

但Date类并没有显式定义拷贝构造函数，则编译器会给Date类生成一个默认的拷贝构造函数

注意：在编译器生成的默认拷贝构造函数中，内置类型是按照字节方式直接拷贝的，而自定

义类型是调用其拷贝构造函数完成拷贝的。

新的问题出来了，那么拷贝构造是构造吗？

class Time
{
public:
	~Time()
	{
		cout << "~Time()" << endl;
	}

	

	Time(const Time& t)
	{
		cout << "Time(const Time& t)" << endl;
		_hour = t._hour;
		_minute = t._minute;
		_second = t._second;
	}

	
private:
	int _hour;
	int _minute;
	int _second;
};

class Date
{
  public:

	Date(int year = 1, int month = 1, int day = 1)
	{
		_year = year;
		_month = month;
		_day = day;
	}
	
		void Print()
	{
		cout << _year << "-" << _month << "-" << _day << endl;
	}
private:
	// 基本类型(内置类型)
	int _year = 1970;
	int _month = 1;
	int _day = 1;
	// 自定义类型
	Time _t;
};

int main()
{
		Date d1(2024, 1, 28);
	Date d2(d1);

	d1.Print();
	d2.Print();

	return 0;
}

我们可以看到time函数不存在默认的构造函数了，说明拷贝构造也是构造。

我们可以用Time() = default; 强制编译器生成

编译器生成的默认拷贝构造函数已经可以完成字节序的值拷贝了，那么还需要自己显式实现吗？

当然像日期类这样的类是没必要的。那么下面的类呢？验证一下试试？

typedef int DataType;
class Stack
{
public:
 Stack(size_t capacity = 10)
 {
 _array = (DataType*)malloc(capacity * sizeof(DataType));
 if (nullptr == _array)
 {
 perror("malloc申请空间失败");
 return;
 }

 _size = 0;
 _capacity = capacity;
 }
 void Push(const DataType& data)
 {

 _array[_size] = data;
 _size++;
 }
 ~Stack()
 {
 if (_array)
 {
 free(_array);
 _array = nullptr;
 _capacity = 0;
 _size = 0;
 }
 }
private:
 DataType *_array;
 size_t _size;
 size_t _capacity;
};
int main()
{
 Stack s1;
 s1.Push(1);
 s1.Push(2);
 s1.Push(3);
 s1.Push(4);
 Stack s2(s1);
 return 0;
}

这里会发现下面的程序会崩溃掉？这里就需要深拷贝去解决

我们调试看看问题出在哪里：

可以看见s1和s2都赋值成功了，那么问题出在哪里呢？

问题出在_array指针上，他们两个同时指向一个空间，当s2指针释放置空后，s1指针会对同一块空间再次置空，一块空间多次释放就会造成程序的崩溃。

同时，类中如果没有涉及资源申请时，拷贝构造函数是否写都可以；一旦涉及到资源申请

时，则拷贝构造函数是一定要写的，否则就是浅拷贝。

深拷贝在这里就是开一块一样的空间给上s2的_array指向。

我们用刚刚出错的代码来深拷贝解决

typedef int DataType;
class Stack
{
public:
	Stack(size_t capacity = 10)
	{
		_array = (DataType*)malloc(capacity * sizeof(DataType));
		if (nullptr == _array)
		{
			perror("malloc申请空间失败");
			return;
		}

			_size = 0;
		_capacity = capacity;
	}

		Stack(const Stack& s)
	{
		DataType* tmp = (DataType*)malloc(s._capacity *(sizeof(DataType)));
		if (tmp == nullptr)
		{
			perror("malloc fail");
			exit(-1);
		}

		memcpy(tmp, s._array, sizeof(DataType) * s._size);

		_array = tmp;
		_size = s._size;
		_capacity = s._capacity;
	}//增加的代码




	void Push(const DataType& data)
	{
		
		_array[_size] = data;
		_size++;
	}
	~Stack()
	{
		if (_array)
		{
			free(_array);
			_array = nullptr;
			_capacity = 0;
			_size = 0;
		}
	}
private:
	DataType* _array;
	size_t _size;
	size_t _capacity;
};
int main()
{
	Stack s1;
	s1.Push(1);
	s1.Push(2);
	s1.Push(3);
	s1.Push(4);
	Stack s2(s1);
	return 0;
}

6.2使用场景

拷贝构造函数典型调用场景

使用已存在对象创建新对象

函数参数类型为类类型对象

函数返回值类型为类类型对象

class Date
{
public:
 Date(int year, int minute, int day)
 {
 cout << "Date(int,int,int):" << this << endl;
 }
 Date(const Date& d)
 {
 cout << "Date(const Date& d):" << this << endl;
 }
 ~Date()
 {
 cout << "~Date():" << this << endl;
 }
private:
 int _year;
 int _month;
 int _day;
};
Date Test(Date d)
{
 Date temp(d);
 return temp;
}
int main()
{
 Date d1(2022,1,13);
 Test(d1);
 return 0;
}

7.赋值运算符重载

7.1运算符重载

C++为了增强代码的可读性引入了运算符重载，运算符重载是具有特殊函数名的函数，也具有其返回值类型，函数名字以及参数列表，其返回值类型与参数列表与普通的函数类似。

函数名字为：关键字operator后面接需要重载的运算符符号。

函数原型：返回值类型 operator操作符(参数列表)

比较类的对象，不能像内置类型一样直接比较。

注意：

1.不能通过连接其他符号来创建新的操作符：比如operator@

2.重载操作符必须有一个类类型参数

3.用于内置类型的运算符，其含义不能改变，例如：内置的整型+，不能改变其含义

4.作为类成员函数重载时，其形参看起来比操作数数目少1，因为成员函数的第一个参数为隐

藏的this

5. . * :: sizeof ?: . 注意以上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;
};

// operator运算符 做函数名
bool operator==(const Date& x, const Date& y)
{
	return x._year == y._year
		&& x._month == y._month
		&& x._day == y._day;
}


bool operator<(const Date& x, const Date& y)
{
	if (x._year < y._year)
	{
		return true;
	}
	else if (x._year == x._year)
	{
		if (x._month < y._month)
		{
			return true;
		}
		else if (x._month == y._month)
		{
			return x._day < y._day;
		}
	}

	return false;
}

int main()
{
	Date d1(2024, 1, 28);
	Date d2(2024, 2, 27);
	cout << operator==(d1, d2) << endl;
	cout << operator<(d1, d2) << endl;

	cout << (d1 == d2) << endl; 
	cout << (d1 < d2) << endl;

	return 0;
}

cout << (d1 == d2) << endl;
cout << (d1 < d2) << endl; //使用括号是因为<<的优先级会高于==，不加括号会报错。

7.2 赋值运算符重载

7.2.1赋值运算符重载格式：

参数类型：const T&，传递引用可以提高传参效率

返回值类型：T&，返回引用可以提高返回的效率，有返回值目的是为了支持连续赋值

检测是否自己给自己赋值

返回*this ：要复合连续赋值的含义

Date d3(d1);//拷贝构造，同类型一个存在的对象进行初始化要创建的对象

d1 = d2;   //已经存在的对象，一个赋值给另一个。

所以为了初始化，我们需要对赋值运算符进行重载。

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) //防止两个数值一样的的赋值情况，如d1=d1，加快运行速率。
       {
            _year = d._year;
            _month = d._month;
            _day = d._day;
       }
        
        return *this;
 }
private:

 int _year ;
 int _month ;
 int _day ;
};

7.2.2赋值运算符只能重载成类的成员函数不能重载成全局函数

class Date
{
public:
	Date(int year = 1900, int month = 1, int day = 1)
	{
		_year = year;
		_month = month;
		_day = day;
	}
	int _year;
	int _month;
	int _day;
};
// 赋值运算符重载成全局函数，注意重载成全局函数时没有this指针了，需要给两个参数
Date& operator=(Date& left, const Date& right)
{
	if (&left != &right)
	{
		left._year = right._year;
		left._month = right._month;
		left._day = right._day;
	}
	return left;
}
// 编译失败：
// error C2801: “operator =”必须是非静态成员

原因：赋值运算符如果不显式实现，编译器会生成一个默认的。此时用户再在类外自己实现

一个全局的赋值运算符重载，就和编译器在类中生成的默认赋值运算符重载冲突了，故赋值

运算符重载只能是类的成员函数。

用户没有显式实现时，编译器会生成一个默认赋值运算符重载，以值的方式逐字节拷贝。

注意：内置类型成员变量是直接赋值的，而自定义类型成员变量需要调用对应类的赋值运算符重载完成赋值。（和拷贝类似）

7.3前置++和后置++重载

class Date
{
public:
 Date(int year = 1900, int month = 1, int day = 1)
 {
 _year = year;
 _month = month;
 _day = day;
 }
 // 前置++：返回+1之后的结果
 // 注意：this指向的对象函数结束后不会销毁，故以引用方式返回提高效率
 Date& operator++()
 {
 _day += 1;
 return *this;
 }
 // 后置++：
 // 前置++和后置++都是一元运算符，为了让前置++与后置++形成能正确重载
 // C++规定：后置++重载时多增加一个int类型的参数，但调用函数时该参数不用传递，编译器
自动传递
 // 注意：后置++是先使用后+1，因此需要返回+1之前的旧值，故需在实现时需要先将this保存
//一份，然后给this+1
 //       而temp是临时对象，因此只能以值的方式返回，不能返回引用
 Date operator++(int)
 {
 Date temp(*this);
 _day += 1;
 return temp;
 }
private:
 int _year;
 int _month;
 int _day;
};

int main()
{
 Date d;
 Date d1(2022, 1, 13);
 d = d1++;    // d: 2022,1,13   d1:2022,1,14
 d = ++d1;    // d: 2022,1,15   d1:2022,1,15
 return 0;
}

8.const成员

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

class Date
{
public:
 Date(int year, int month, int day)
 {
 _year = year;
 _month = month;
 _day = day;
 }
 void Print()
 {
 cout << "Print()" << endl;
 cout << "year:" << _year << endl;
 cout << "month:" << _month << endl;
 cout << "day:" << _day << endl << endl;
 }
 void Print() const
 {
 cout << "Print()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(2022,1,13);
 d1.Print();
 const Date d2(2022,1,13);
 d2.Print();
}

这里写的原因涉及到之前我们在初识C++（下）介绍过权限，这里有涉及。

请思考下面的几个问题：

1. const对象可以调用非const成员函数吗？

2. 非const对象可以调用const成员函数吗？

3. const成员函数内可以调用其它的非const成员函数吗？

4. 非const成员函数内可以调用其它的const成员函数吗？

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

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

class A
{
public:
	
	A* operator&()
	{
		
		return this;
	}

	
	const A* operator&() const
	{
		return this;
	}

	
};

int main()
{
	A aa1;
	const A aa2;

	// 日常都不需要我们写，编译器默认生成就够用了
	cout << &aa1 << endl;
	cout << &aa2 << endl;

	return 0;
}

我们去掉成员函数：

class A
{
public:

	

};

int main()
{
	A aa1;
	const A aa2;

	// 日常都不需要我们写，编译器默认生成就够用了
	cout << &aa1 << endl;
	cout << &aa2 << endl;

	return 0;
}

如果不想对方取得我们的地址我们可以这样写覆盖掉默认生成的成员函数：

class A
{
public:
	 
	A* operator&()
	{
		//return this;
		return nullptr;
		
	}

	
	//const A* operator&() const
	//{
	//	return this;
	//}

	const A* operator&() const
	{
		return (const A*)0x00eeffee;
	
	}
};

int main()
{
	A aa1;
	const A aa2;

	// 日常都不需要我们写，编译器默认生成就够用了
	cout << &aa1 << endl;
	cout << &aa2 << endl;

	return 0;
}