C++（4）--- 类和对象(中)

于 2025-05-05 00:03:05 发布
阅读量611 收藏 19
点赞数 25
分类专栏： C++ 文章标签： c++ 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2401_85214846/article/details/147522633
版权

类和对象 --- 中

一、类的默认成员函数

在C++中，类中会存在一些默认成员函数，在特定的场景下进行一些操作。
默认成员函数就是用户没有显式实现，编译器会⾃动⽣成的成员函数称为默认成员函数。
在C++11之前一共有6个，其中前4个非常重要，后两个相较于前四个没有特别重要，了解知道即可。

在这里插入图片描述

我们要从两个⽅⾯去学习：
• 第⼀：我们不写时，编译器默认⽣成的函数⾏为是什么，是否满⾜我们的需求。
• 第⼆：编译器默认⽣成的函数不满⾜我们的需求，我们需要⾃⼰实现，那么如何⾃⼰实现？

二、构造函数

2.1概念

构造函数是六大默认成员函数之一，其功能是将实例化对象进行初始化操作，也就是常见于数据结构中Init方法。

2.2特点

1）函数名与类名相同。
2）没有返回值，是连void都没得那种，C++规定如此。
3）对象实例化时系统会⾃动调⽤对应的构造函数。
4）构造函数可以重载，也就是说构造函数可以不止一个。
5）如果类中没有显式定义构造函数，则C++编译器会⾃动⽣成⼀个⽆参的默认构造函数，⼀旦⽤户显式定义编译器将不再⽣成。
6）其C++编译器⾃动⽣成⽆参的默认构造函数，对内置类型成员变量的初始化没有要求，也就是说是是否初始化是不确定的，看编译器；而对自定义类型，会调用该类型的默认构造函数，如果该类型没有构造函数，则会报错。
7）注意，默认构造函数不只是不写构造时编译器默认⽣成的构造函数，无参构造函数，全缺省构造函数，这些也叫做默认构造函数，其中这三个相互互斥，这三个函数有且只有⼀个存在，不能同时存在。无参构造函数和全缺省构造函数，语法上构成函数重载，但在函数调用上会产生歧义。总结⼀下就是不传实参就可以调⽤的构造就叫默认构造。

2.3例子

示例一：显式定义构造函数

示例代码如下：

//示例一：显式定义构造函数
class Date
{
public:

	//我们显示定义构造函数
	//1.无参构造方法
	Date()
	{
		_year = 1;
		_month = 1;
		_day = 1;
	}

	//2.有参构造方法
	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;
};

//main
int main()
{
	Date d1;               //调用无参构造方法
	Date d2(2025, 4, 26);  //调用有参构造方法

	//观察是否初始化成功
	d1.Print();
	d2.Print();

	return 0;
}

运行结果：
在这里插入图片描述

调试观察：
在这里插入图片描述
首先观察两个构造函数（此时已体现函数重载），函数名与类名一致，并且没有返回值，其次main函数内，d1为无参，d2为有参，根据各自参数的不同，调用了满足自身的构造函数。

示例二：没有定义构造函数

对于内置类型示例代码如下：

//示例二：内置类型没有定义构造函数
class Date
{
public:
	void Print()
	{
		cout << _year << "/" << _month << "/" << _day << endl;
	}

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

int main()
{
	Date d1;     //调用编译器自己生成的无参构造函数               

	//观察是否初始化成功
	d1.Print();

	return 0;
}

运行结果：
在这里插入图片描述
由结果可知，vs编译器下，对内置类型的成员变量初始化成随机值。

对于自定义类型示例代码如下：

//自定义类型没有定义构造函数
typedef int STDataType;
class Stack
{
public:
	Stack(int n = 4)
	{
		_a = (STDataType*)malloc(sizeof(STDataType) * n);
		if (nullptr == _a)
		{
			perror("malloc申请空间失败");
			return;
		}
		_capacity = n;
		_top = 0;
	}
	// ...
private:
	STDataType * _a;
	size_t _capacity;
	size_t _top;
};

// 两个Stack实现队列
class MyQueue
{	
private:
	Stack pushst;
	Stack popst;
};

//main
int main()
{
	MyQueue q;  //创建一个MyQueue对象，此时调用默认构造函数
	return 0;
}

调试观察：
在这里插入图片描述
对于自定义类型的对象，会调用此类型的默认构造函数，从而完成初始化操作，在上述代码示例中用MyQueue类（本身没有构造函数）创建的对象q，调用了Stack类的构造函数，完成初始化操作。

三、析构函数

3.1概念

析构函数是六大默认成员函数之一，其功能是用来清理对象产生的资源，类似于C语言数据结构阶段的Destroy方法。不是将对象进行销毁操作的，这个对象一般定义的是局部变量，在main函数结束就自动由编译器销毁了，析构函数不是进行这些操作的。

3.2特点

1）函数名与类名相同，并且在函数名之前加上~符。
2）没有返回值，与构造函数相似
3）⼀个类只能有⼀个析构函数。若未显式定义，系统会⾃动⽣成默认的析构函数。
4）对象⽣命周期结束时，系统会⾃动调⽤析构函数。
5）跟构造函数类似，我们不写编译器⾃动⽣成的析构函数对内置类型成员不做处理，⾃定类型成员会调⽤他的析构函数。
6）⼀个局部域的多个对象，C++规定后定义的先析构。

3.3例子

示例一：显示定义析构函数

由于析构函数对于内置类型不做处理（这点和构造函数一样），所以下文的场景都是拿自定义类型来举例。
示例代码如下：

//自定义类型显示定义析构函数
typedef int STDataType;
class Stack
{
public:
	Stack(int n = 4)
	{
		_a = (STDataType*)malloc(sizeof(STDataType) * n);
		if (nullptr == _a)
		{
			perror("malloc申请空间失败");
			return;
		}
		_capacity = n;
		_top = 0;
	}
	
	~Stack()
	{
		cout << "~Stack()" << endl;    //标记作用，观察是否会被调用
		free(_a);
		_a = nullptr;
		_capacity = _top = 0;
	}
private:
	STDataType* _a;
	size_t _capacity;
	size_t _top;
};

int main()
{
	Stack s;
	return 0;
}

运行结果：
在这里插入图片描述

在main函数内，我们没有调用析构函数，也就印证了对象在生命周期结束的时候会自动调用对应的析构函数，来清理资源。

示例二：没有定义析构函数

// 两个Stack实现队列
class MyQueue
{
private:
	Stack pushst;
	Stack popst;
};

//main
int main()
{
	MyQueue q;
	return 0;
}

运行结果：
在这里插入图片描述
对于MyQueue类，没有显示定义构造函数，其默认就调用Stack类的析构函数。

四、拷贝构造函数

4.1概念

拷贝构造也是构造函数，是上文构造函数的重载，其功能是当创建对象时，使用相同类型的对象进行构造这种情况，将相同类型的对象的初始化成员变量的值复制到新对象这种操作。

4.2特点

1）拷贝构造是构造函数的重载。
2）拷贝构造函数的第一个参数是其相同类型的引用，若为传值传参，则会在语法逻辑上发生无穷递归调用，陷入死循环。拷⻉构造函数也可以多个参数，但是第⼀个参数必须是类类型对象的引⽤，后⾯的参数必须有缺省值。
解释为何要是引用传参而不是传值传参：
示例场景：

void F(Date d)
{
	
}

int main()
{
	F(d1);        //传值传参这一过程会先调用拷贝构造，再进入F函数
	return 0;
}

这里将d1传值传参给F函数，由于是传值传参，所以有形参是实参的临时拷贝，C++规定但凡是拷贝，都会在这一过程调用到拷贝构造函数，之后拷贝构造结束，在返回进入F函数。
也就是如下图这样（右边的构造函数就是拷贝构造函数）：
在这里插入图片描述这个就是特点2）中的语法逻辑。
了解这个之后引申到拷贝构造函数，假设拷贝构造函数使用的是传值传参，main内实参传递过来发生临时拷贝，调用拷贝构造函数，这里拷贝构造函数还是传值传参，会发现这样下去会一直调用拷贝构造函数，不会像上面语法一样，先调用拷贝构造函数再返回进F函数，这样也就发生了无穷递归调用。
所以这里只能是使用传引用传参。
3）C++规定⾃定义类型对象进⾏拷⻉⾏为必须调⽤拷⻉构造，所以这⾥⾃定义类型的传值传参和传值返回都会调⽤拷⻉构造完成（也就是上面的语法）。
4）若未显式定义拷⻉构造，编译器会⽣成⾃动⽣成拷⻉构造函数。⾃动⽣成的拷⻉构造对内置类型成员变量会完成值拷⻉/浅拷⻉(⼀个字节⼀个字节的拷⻉)，对⾃定义类型成员变量会调⽤他的拷⻉构造。
5）对于内置类型，我们不写拷贝构造，编译器默认生成的就已经能完成我们的需求了，因为是内置类型这种类创建的对象，是没有什么资源可言的；对于自定义类型，创建的对象很大程度上都是有资源的，所以我们不写时，编译器默认生成的拷贝构造函数的行为（浅拷贝）是不能满足自定义类型的，因为还要将资源也进行拷贝（深拷贝）。
6）拷贝构造是一个传引用传参的函数，所以⼀定要确保返回对象，在当前函数结束后还在，才能⽤引⽤返回。否则就会形成像野引用（类比野指针）这样的行为，是极度“危险”的。

4.3例子

示例一：显示定义拷贝构造函数

对于内置类型示例代码如下：

//1.内置类型
class Date
{
public:
	void Print()
	{
		cout << _year << "/" << _month << "/" << _day << endl;
	}

	//普通构造
	Date(int year = 1, int month = 1, int day = 1)
	{
		_year = year;
		_month = month;
		_day = day;
	}

	//拷贝构造
	Date(Date& d)
	{
		_year = d._year;
		_month = d._month;
		_day = d._day;
	}

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

//main
int main()
{
	Date d1(2025,4,28);    //调用普通构造
	Date d2(d1);           //调用拷贝构造

	return 0;
}

调试观察：
在这里插入图片描述
对于内置类型的拷贝构造，就是一个浅拷贝的样式，只有这些普通变量值的拷贝。

对于自定义类型示例代码如下：

//2.自定义类型
typedef int STDataType;
class Stack
{
public:
	//普通构造
	Stack(int n = 4)
	{
		_a = (STDataType*)malloc(sizeof(STDataType) * n);
		if (nullptr == _a)
		{
			perror("malloc申请空间失败");
			return;
		}
		_capacity = n;
		_top = 0;
	}

	//拷贝构造
	Stack(Stack& s)
	{
		_a = (STDataType*)malloc(sizeof(STDataType) * s._capacity);
		if (nullptr == _a)
		{
			perror("malloc申请空间失败");
			return;
		}

		memcpy(_a, s._a, sizeof(STDataType) * s._top);

		_top = s._top;
		_capacity = s._capacity;
	}

	void Push(const STDataType& p)
	{
		_a[_top++] = p;
	}

	~Stack()
	{
		cout << "~Stack()" << endl;    //标记作用，观察是否会被调用
		free(_a);
		_a = nullptr;
		_capacity = _top = 0;
	}
private:
	STDataType* _a;
	size_t _capacity;
	size_t _top;
};

int main()
{
	Stack s1;
	Stack s2(s1);

	return 0;
}

调试观察：
在这里插入图片描述
对于自定义类型的对象，拷贝构造不仅要将值拷贝，还要将资源（动态申请的空间这类的）进行拷贝。

示例二：不定义拷贝构造函数

对于内置类型就是示例一中将拷贝构造函数删除，此时还要进行此类拷贝操作，调用的就是编译器默认生成的拷贝构造函数，对于内置类型而言，编译器生成的拷贝构造行为就是一个浅拷贝行为，将值进行了拷贝。
调试观察：
在这里插入图片描述
没有写拷贝构造函数，编译器生成的拷贝构造也可以完成需求，并且不会报错。

对于自定义类型将示例一中拷贝构造函数删除，
调试观察：
在这里插入图片描述

运行结果：
在这里插入图片描述
怎么明明调试的时候也是完成了拷贝啊，可运行的时候会报错呢，这也印证了特点5），对于自定义类型，我们不写拷贝构造函数，编译器默认生成的拷贝构造行为是一个浅拷贝行为，之将值拷贝了，而此时对象中还有动态申请的资源，所以此时的默认生成的拷贝构造满足不了需求。
也就是下图这种情况：
在这里插入图片描述
此时会有一个对象修改了指向的内容，另一方也会被修改，最主要的是在对象生命周期结束之后会自动调用析构函数，导致此资源被析构两次，这才是程序崩溃的元凶。

所以对于Stack类来说，不能不写拷贝构造函数（我们在示例一写出的拷贝构造就将资源也拷贝了），但是有一种情况是不用写拷贝构造的：

// 两个Stack实现队列
class MyQueue
{
private:
	Stack pushst;
	Stack popst;
};

//main
int main()
{
	MyQueue q1;
	MyQueue q2(q1);
	return 0;
}

调试观察：
在这里插入图片描述
对于MyQueue类，我们没有显示定义拷贝构造就完成了需求，并且没有报错，此时像MyQueue这样的类型内部主要是⾃定义类型Stack成员，编译器⾃动⽣成的拷⻉构造会调⽤Stack的拷⻉构造，也就不需要我们显⽰实现MyQueue的拷⻉构造。

五、 运算符重载

5.1概念

当运算符被⽤于类类型的对象时，C++语⾔允许我们通过运算符重载的形式指定新的含义。
也就是说运算符重载是一个函数，他的名字是由operator和后⾯要定义的运算符共同构成。
和其他函数⼀样，它也具有其返回类型和参数列表以及函数体。

5.2特点

1）类类型对象使⽤运算符时，必须转换成调⽤对应运算符重载，若没有对应的运算符重载，则会编译报错。
2）运算符重载的参数个数和运算符的操作数个数相同，一元就是一个参数，二元就是两个参数，并且二元左边的操作数传参给左边的形参，二元右边的操作数传参给右边的形参。
3）当运算符重载是类中的成员函数时，其参数是运算符操作数减一，因为成员函数隐含了this指针，第一个操作数会传参给this指针。
4）运算符重载以后，其优先级和结合性与对应的内置类型运算符保持⼀致。
5）不能重载没有的运算符。
6）以下运算符没有重载：.*(表示成员函数的函数指针)、sizeof、::(作用域限定符)、?:(三目运算符)、.(成员访问符)。
7）运算符重载不能想重载什么就重载什么，要具有实际的意义，比如Date日期类，operator-就有意义（能计算两个日期之间的差值），而operator+就没啥意义。

5.3例子

示例一：运算符重载作为全局函数

这里使用上面的日期类Date类，运算符使用==做演示：

//全局函数：
bool operator==(const Date& s1, const Date& s2)
{
	return s1._year == s2._year
		&& s1._month == s2._month
		&& s1._day == s2._day;
}

int main()
{
	Date d1(2025, 5, 1);
	Date d2(2025, 5, 1);
	Date d3(2020, 5, 1);

	//显示调用：
	cout << "operator==(x1,x2)的形式" << endl;
	cout << operator==(d1, d2) << endl;;   //此时输出1，代表真
	cout << operator==(d1, d3) << endl;    //此时输出0，代表假

	cout << "" << endl;
	//也可以直接这样写 ---- (== 的优先级比 << 低)
	cout << "(x1==x2)的形式" << endl;
	cout << (d1 == d2) << endl;   //此时输出1，代表真
	cout << (d1 == d3) << endl;   //此时输出0，代表假
    //其实是编译器最后会将 d1 == d2 转化成：operator==(d1,d2)


	return 0;
}

运行结果：
在这里插入图片描述
运算符重载作为全局函数时会到一个问题，就是通常类中的成员变量都是设置为私有的，那么在类外就不能访问成员变量，所以面临这种问题有以下几种方案：
（1）将权限设置为公有，示例一就是如此，但是不推荐这样。
（2）Date类中提供get成员变量的函数，此方法java语言常用，但C++语言里使用较少。
（3）友元函数 — 此方法我在类和对象(下)中将。
（4）重载为成员函数。

示例二：运算符重载作为成员函数

class Date
{
public:
	//...
	
	//成员函数：
	bool operator==(const Date& x1)
	{
		return _year == x1._year
			&& _month == x1._month
			&& _day ==x1._day;
	}
	
	private:
	int _year;
	int _month;
	int _day;
};

//运算符重载为成员函数时的用法：
int main()
{
	Date d1(2025, 5, 1);
	Date d2(2025, 5, 1);

	//显示调用：
	cout << "x1.operator(x2)的形式" << endl;
	cout << d1.operator==(d2) << endl;       //此时就是作为成员函数来使用
	cout << d2.operator==(d1) << endl;
	
	//同样编译器最后也会将 d1 == d2 转化成：d1.operator==(d2)
	//依旧可以按照上述 d1==d2 这样写。

	return 0;
}

特例1：赋值运算符重载 - - - 只能是成员函数

概念：
赋值运算符重载即“=”的重载，这是一种特殊的运算符重载，其功能是完成对对象的拷贝，此功能和拷贝构造相似，但有些许不同。

不同点1：
拷贝构造是一个已初始化的对象和未初始化的对象之间进行的操作。
赋值运算符重载是两个已初始化的对象之间进行的操作。

不同点2：
拷贝构造必须是要传引用传参，不能传值传参，否则会发生无穷递归。
赋值运算符重载可以是传引用传参，也可以是传值传参，但依旧推荐使用传引用传参，可以减少拷贝。

特点：
1.赋值运算符重载被C++规定只能是成员函数，不能是全局函数。
2.此重载的参数列表即可以使用传值传参，也可以使用传引用传参，但依旧推荐使用传引用传参，可以减少拷贝。
3.此重载的返回值没有固定是无返回值还是有返回值，但推荐写成有返回值，并且还是传引用返回，这样不仅能减少拷贝，也能完成连续赋值的操作。
4…赋值运算符重载和拷贝构造类似，我们不显示写赋值运算符重载时，编译器会默认生成一个赋值运算符重载，而此重载对于类的成员变量是内置类型这种，进行的是浅拷贝形式，对于自定义类型这种，会调用自己赋值运算符重载。
所以基于第4点，对于Date类这种成员变量全是内置类型这种且没有资源，编译器自己生成的赋值运算符重载就能够满足我们的需求了；而对于上面的Stack类，其成员变量虽然也是内置类型，但是存在资源，编译器默认生成的重载不能满足我们的的需求，所以此时就必须我们自己显示的写重载；对于Myqueue类，它不用自己显示的写赋值运算符重载，它会调用Stack类的重载函数。

示例：
使用上述Date类来举实例：

//在Date类中：

	//拷贝构造
	Date(Date& d)
	{
		_year = d._year;
		_month = d._month;
		_day = d._day;
	}

	//赋值运算符重载
	Date& operator=(const Date& x)
	{
		_year = x._year;
		_month = x._month;
		_day = x._day;

		return *this;
	}
	
//main函数中：
int main()
{
	Date d1(2025, 5, 3);
	Date d3(2020, 5, 3);

	//下面两种写法都可以
	//拷贝构造的对象是一个已初始化的对象和一个未初始化的对象
	//Date d2(d1);           
	Date d2 = d1;             //此时调用的是拷贝构造

	//下面两种写法都可以
	//赋值运算符重载的对象是两个已初始化的对象
	//d1.operator=(d3);       
	d1 = d3;                  //此时调用的是赋值运算符重载

	return 0;
}

对赋值运算符重载调试观察：
在这里插入图片描述
其实上述赋值运算符重载的代码还有一些缺陷，赋值运算符在语法上是支持自己给自己赋值的，就例如d1 = d1，这样的表达式语法上没问题，但是没有实际意义，所以可以在函数体第一句加上不能传自己的if判断或者assert断言。

正确的赋值运算符重载：

	//赋值运算符重载
	Date& operator=(const Date& x)
	{
		if (this != &x)         
		{
			_year = x._year;
			_month = x._month;
			_day = x._day;
		}
		return *this;
	}

赋值运算符在语法上也支持连续赋值，例如d1 = d2 = d3，上述代码同样也能实现。
调试观察：
在这里插入图片描述

特例2：前置后置++ --运算符重载

对于前置后置++，–运算符运算符重载operator不能分辨出是前置还是后置的用法，所以C++规定在后置的运算符重载的参数列表里多添加一个int参数，此参数只用于区分前置和后置，将其两个运算符重载形成函数重载。

使用上述Date类来举实例：

//前置++运算符重载
Date& Date::operator++()
{
	//前置++：先加一再使用
	*this = *this + 1;
	return *this;
}

//后置++运算符重载
Date Date::operator++(int)
{
	//后置++：先使用在加一
	Date temp(*this);
	temp = temp + 1;
	return temp;
}

//前置--运算符重载
Date& Date::operator--()
{
	//前置--：先减一再使用
	*this = *this - 1;
	return *this;
}

//后置--运算符重载
Date Date::operator--(int)
{
	//后置--：先使用在减一
	Date temp(*this);
	temp = temp - 1;
	return temp;
}
//main函数内：
int main()
{
	//前置++
	Date d1(2025,5,31);
	//d1.operator++();    //显示调用
	++d1;
	cout << "前置++：";
	d1.Print();

	//后置++
	Date d2(2025,5,31);
	//d2.operator++(0);     //显示调用
	Date d5 = d2++;
	cout << "后置++：先使用";
	d2.Print();
	cout << "后置++：再加一";
	d5.Print();

	//前置--
	Date d3(2025, 5, 1);
	//d3.operator--();      //显示调用
	--d3;
	cout << "前置--：";
	d3.Print();

	//后置--
	Date d4(2025, 5, 1);
	//d3.operator--(0);     //显示调用
	Date d6 = d4--;
	cout << "后置--：先使用";
	d4.Print();
	cout << "后置--：再减一";
	d6.Print();
}

运行结果：
在这里插入图片描述
中间的-，+，=等的运算符也是调用的我们定义的重载，这是一种复用。

特例3：流插入、提取运算符重载 - - - 最好是全局函数

流插入、提取运算符重载可以写成成员函数，也可以写成全局函数，没有硬性规定，但是建议写为全局函数，因为成员函数的参数列表第一个参数是不显示的this形参，会导致抢占位置，写出可读性差，难理解的代码，例如： 对象<<cout。

示例代码如下：

class Date
{
    //......
    
	// 友元函数声明
	friend ostream& operator<<(ostream& out, const Date& x);
	friend istream& operator>>(istream& in, Date& x);
	
    //......
}

//类外：运算符重载的声明
//<<流插入运算符重载
ostream& operator<<(ostream& out, const Date& x);
//>>流插入运算符重载
istream& operator>>(istream& in, Date& x);

//cpp文件 --- 运算符重载的定义
//<<流插入运算符重载
ostream& operator<<(ostream& out, const Date& x)
{
	out << x._year << "年" << x._month << "月" << x._day << "日" << endl;
	return out;
}

//>>流插入运算符重载
istream& operator>>(istream& in, Date& x)
{
	in >> x._year >> x._month >> x._day;
	return in;
}

//main函数内：
int main()
{
	Date d1, d2;
	cout << "请输入年月日：" << endl;
	cin >> d1 >> d2;
	cout << d1 << d2;

	return 0;
}

运行结果：
在这里插入图片描述
由于此运算符重载是定义为全局函数，所以为了解决成员变量私有，类外无法访问的问题，这里使用友元函数（其具体定义和使用详见下篇博客）解决此问题，友元函数的定义需在类中；注意流提取的第二个参数不要写成const修饰的，因为是in去插入进x，x被设定了新的值，所以不能加const。

六、取地址操作符重载

取地址操作符重载也是默认成员函数之一，作用是取出自定义对象的地址，在讲此重载之前要先了解const成员函数。
const成员函数也就是对象是被const修饰的对象时，调用其对应的成员函数（没有const修饰时）会导致权限的放大，无法正确的调用，所以在面对const修饰的对象时，调用的成员函数也需要有const修饰。
const成员函数示例代码如下：

//Date类中： --- 声明
void Print() const;

//cpp文件内： --- 定义
// void Print(const Date* const this) const
void Date::Print() const
{
	cout << _year << "/" << _month << "/" << _day << endl;
}

//main函数内：
int main()
{
	//正常对象
	Date d1(2025, 5, 4);
	d1.Print();

	//const对象
	const Date d2(2020, 5, 4);
	d2.Print();
}

d2是一个const修饰的对象，所以在调用成员函数的时候，例如此时的Print函数，在没有加const时，提示d2没有可用成员，加入const时才能使用，这里涉及权限的放大，并且成员函数添加const时是在函数尾添加，需要注意别添加错了。成员函数成为const成员函数时正常对象也能自由调用，这里就是权限的缩小。

取地址操作符重载就是在此基础上讲的。
示例代码如下：

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

	const Date* operator&() const
	{
		return this;
	}
//main函数内：

	cout << &d1 << endl;
	cout << &d2 << endl;

调用结果（d1）：
在这里插入图片描述
调用结果（d2）：
在这里插入图片描述

这里定义两个重载，相当于对号入座，是const修饰的对象就调用const成员函数，非const修饰的对象就调用非const成员函数，这样更加准确。

但是因为是默认成员函数，我们不写编译器会自动生成一个重载，并且此重载特别简单，基本上编译器生成的就可以满足我们的需求，所以在程序中我们是不用显示的去写取地址操作符重载的。

评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值