C++学习————第六天（运算符重载 const成员取地址）

island1314

已于 2024-04-18 22:54:30 修改

阅读量962

点赞数 34

分类专栏： C++学习文章标签：学习

于 2024-04-16 23:39:40 首次发布

本文链接：https://blog.csdn.net/island1314/article/details/137756026

版权

C++学习专栏收录该内容

8 篇文章 1 订阅

订阅专栏

这一篇我们来补齐上一天的留下的三个默认成员函数

//上一天内容：

https://blog.csdn.net/island1314/article/details/137371086?spm=1001.2014.3001.5502https://blog.csdn.net/island1314/article/details/137371086?spm=1001.2014.3001.5502

1、重载

1.1 运算符重载

即当重载成为全局无法访问类的私有成员，解决方法：

原因是因为拷贝构造是把一个已经存在的对象，拷贝初始化另一个要创建初始化的对象

a、赋值运算符重载格式

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

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

1、重载

1.1 运算符重载

C++为了增强代码的可读性引入了运算符重载，运算符重载是具有特殊函数名的函数，也具有其返回值类型，函数名字以及参数列表，其返回值类型与参数列表与普通的函数类似。
函数名字为：关键字operator 后面接需要重载的运算符符号。
函数原型：返回值类型 operator操作符(参数列表)

比如 Date 日期类返回值

bool operator < (const Date& d1, const Date& d2)
Date operator++(Date &d) // 返回值函数 Date

d1 < d2 -> bool
++d1 -> Date
d1 - d2 -> int 有意义
d1 - 100 -> Date d1 + 100-> Date

注意：
1、不能通过连接其他符号来创建新的操作符（必须是c语言和c++有的操作符）：比如 operator@ 就不行
2、重载操作符必须有一个类类型参数： 比如int operator-(int i,int j)就不可以
3、用于内置类型的运算符，其含义不能改变，例如：内置的整型+，不能改变其含义（但是有些情况中是可以改变的）
4、作为类成员函数重载时，其形参看起来比操作数数目少1，因为成员函数的第一个参数为隐藏的this
5、 .*（） ::（域作用限定符） sizeof （sizeof运算符） ?: （三目操作符） . （对象点）注意以上5个运算符不能重载。这个经常在笔试选择题中出现。

.* 运算符的使用

// 哪些运算符需要重载：（按需重载）

d1+d2没有意义，d1*d2没有意义，因此一个类重载哪些运算符要看需求，看重载是否有价值和意义

运算符重载样例代码：

这里会发现运算符重载成全局的就需要成员变量是公有的，那么问题来了，假如把类的成员变量改为私有则 operator 会报错 ，此时封装性如何保证？
这里其实可以用我们后面学习的友元解决，或者干脆重载成成员函数。

即当重载成为全局无法访问类的私有成员，解决方法：

1、提供这些成员get 和 set

2、友元

3、重载成为成员函数（一般使用这种）

显示写出成员函数，其实可以不用显示写

成员函数的调用

下面为上面两者汇编，因此可知转换调用等价于上面的调用

当全局和局部同时存在的时候，优先调用类里面的，不会报错。

1.2 赋值运算符重载

赋值重载理解：

原因是因为拷贝构造是把一个已经存在的对象，拷贝初始化另一个要创建初始化的对象

赋值重载（赋值拷贝）是把一个已经存在的对象，拷贝赋值给是把另一个已经存在的对象

a、赋值运算符重载格式

1、参数类型：const T&，传递引用可以提高传参效率
2、返回值类型：T&，返回引用可以提高返回的效率，有返回值目的是为了支持连续赋值

3、检测是否自己给自己赋值
4、返回 *this ：要复合连续赋值的含义

5、重载的赋值运算符函数参数只有一个，另一个通过this指针传递。

this 指针返回：

但是这个不能实现

因此可以改成

传值返回和引用返回区别：

代码演示：

由于打印结果 ref 和 d 地址相同，易知在引用返回中 ref 是 d 的别名

但是再加一个下面的全局函数，可以发现引用返回的问题

但是当我们改成

出了函数作用，返回对象还在，才能引用返回，减少拷贝
a、返回对象生命周期到了，会析构，传值返回
b、返回对象生命周期没到了，不会析构，传引用返回

总结：返回对象是一个局部对象或者临时对象，出了当前函数作用域，就析构销毁了，那么就不能引用返回，用引用返回是存在风险的，因为引用对象在func函数栈帧已经销毁了，虽然引用返回可以减少一次拷贝，但是出了函数作用，返回对象还在，才能引用返回

正确代码演示：

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

		return *this;
	}
private:
	int _year;
	   int _month;
	   int _day;
};

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

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

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

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

// 这里会发现下面的程序会崩溃掉？这里就需要我们以后讲的深拷贝去解决。
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)
	{
		// CheckCapacity();
		_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;
	s2 = s1;
	return 0;
}

注意：如果类中未涉及到资源管理，赋值运算符是否实现都可以；一旦涉及到资源管理则必
须要实现。

d、六大比较运算符的实现

函数声明：

函数实现：

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) return _day < d._day;
	}
	return false;
}

// d1 <= d2
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 _year == d._year
		&& _month == d._month
		&& _day == d._day;
}

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

1.3 前置++和后置++重载

样例代码1：

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

样例代码2：

这里我们用到了代码复用，可以仔细看看

// ++d1
Date& Date:: operator ++()
{
	*this += 1;
	return *this;
}

// ++d1
Date Date:: operator++(int i)
{
	cout << i << endl;
	Date tmp(*this);
	*this += 1;
	return tmp;
}


 两个交换 不会报错 打印也没有问题
 ++d1
//Date Date:: operator ++()
//{
//	Date tmp(*this);
//	*this += 1;
//	return tmp;
//}
//
 d1++
//Date& Date:: operator++(int i)
//{
//	*this += 1;
//	return *this;
//}


Date& Date:: operator --()
{
	*this -= 1;
	return *this;
}

Date Date:: operator --(int)
{
	Date tmp = *this;
	*this -= 1;
	return tmp;
}

代码复用

1.4 流插入流提取

之所以不用 printf 和 scanf 是因为他俩只支持内置类型

1、定义在类的函数

此时类的成员变量可以为私有

函数名：

函数实现：

实参传递：

结果演示：

2、全局函数：

当变成全局的时候，这时的成员变量需要是公有的

函数名：

函数实现：

实参传递：

结果演示：

3、友元函数

函数名：

只需要改变函数名即可，就可以在私有成员变量下使用，函数实现和结果演示均不发生改变

分析：

实参顺序（操作数顺便本质上就是实参顺序）

请强烈注意：！！！！！！！！！！！

赋值运算符在类中不显式实现时，编译器会生成一份默认的，此时用户在类外再将赋值运算符重载为全局的，就和编译器生成的默认赋值运算符冲突了，故赋值运算符只能重载成成员函数

2、const成员

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

代码1 比如：

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

代码2演示如下：

const 不能修饰+= ,因为会使*this无法修改，因此函数中需要修改成员的都不能使用const

代码如下：

若要加 const 对前面的函数代码实现进行部分修改即可，如：

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

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

#include <iostream>

using namespace std;

class A
{
public:
	// 我们不实现，编译器也会实现，一般不需要我们自己实现
	A* operator&()
	{
		cout << "A* operator&()" << endl;

		return this;
	}

	const A* operator&() const
	{
		cout << "const A* operator&() const" << endl;
		return this;
	}

private:
	int _a1 = 1;
	int _a2 = 2;
	int _a3 = 3;
};

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

	cout << &aa1 << endl;
	cout << &aa2 << endl;

	return 0;
}

除非不想让别人取到这个类型对象的真实地址,给假地址

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

island1314

关注

34
点赞
踩
27

收藏

觉得还不错? 一键收藏
9
评论
C++学习————第六天（运算符重载 const成员取地址）

这一篇我们来补齐上一天的留下的三个默认成员函数//上一天内容：nullhttps://blog.csdn.net/island1314/article/details/137371086?spm=1001.2014.3001.5502 C++为了增强代码的可读性引入了运算符重载，运算符重载是具有特殊函数名的函数，也具有其返回值类型，函数名字以及参数列表，其返回值类型与参数列表与普通的函数类似。函数名字为：关键字operator 后面接需要重载的运算符符号。函数原型：返回值类型
复制链接

扫一扫