运算符重载

最新推荐文章于 2024-08-25 11:21:17 发布
最新推荐文章于 2024-08-25 11:21:17 发布
阅读量1.4k 收藏 6
点赞数 1
分类专栏： 杂谈 文章标签： c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yuckh/article/details/120126578
版权
本文详细介绍了C++中的运算符重载，包括成员函数和友元函数的重载方式，以及自增自减、流提取运算符的重载规则。并展示了如何通过运算符重载实现一个向量类Vec2D，包含加减、自增自减、索引访问等操作，并提供了相应的代码示例。
摘要由CSDN通过智能技术生成

运算符重载

运算符重载的特点

可以将运算符实际就是函数，运算符重载实际就是函数重载，运算符重载有两种形式：重载为类的成员函数，重载为类的非成员函数（一般为友元）。

重载为类的成员函数时，函数的参数个数比原来的操作数要少一个

(this作为一个成员，另一个对象作为另一个成员)
1、双目运算符重载为类的成员函数时，函数只显示说明一个参数，该形参是运算符的右操作数。(a+b)
2、前置单目运算符重载为类的成员函数时，不需要显示说明参数，即该函数没有形参。(++a)
3、后置单目运算符重载为类的成员函数时，函数要带有一个整形形参。(a++)
在这里插入图片描述

重载为类的非成员函数时，函数的参数个数一般为两个

成员函数运算符与友元函数运算符的异同

  • 一般情况下，单目运算符最好重载为类的成员函数；双目运算符最好重载为类的友元函数
  • 若运算符所需的操作数希望有隐式类型转换，则只能选择友元函数。
  • 当运算符函数是一个成员函数时，最左边的操作数必须是运算符类的一个类对象。

不可重载的运算符

. 类属关系运算符
.* 成员指针运算符
:: 作用域运算符
? : 条件运算符
#：编译预处理符号
sizeof() 取数据类型的长度

左值Lvalue与右值Rvalue

左值:能出现在赋值运算符“=”的左边，能被赋值；
右值：出现在赋值运算符“=”的右边，不能被赋值。
是不是尽量都重载为一个左值？
例：重载r1[i]；

double& Vec2D::operator[](const int index)
{
	if (index == 0)return x;
	else if (index == 1)return y;
	else cout << "检索超过范围" << endl;
}

在double后面加一个&，就表示重载为左值，此时可以进行赋值。

重载自增自减运算符

PS：C语言里头，前自增和后自增都是一个右值，在C++里头看你怎么重载的自增运算符！

前置与后置的区别

前置重载无参数，返回引用类型。
后置重载带参数，一般使用一个int来区别，但是不参与运算。
在这里插入图片描述

重载流提取运算符(<<,>>)

只能重载为友元函数
原因如下：使用<<和>>运算符时，第一个参数是流类的实例：cout<<x<<y；但是如果重载为类成员函数，当调用该运算符后，左操作数必须是该类的实例，形式为 r1<<cout；不符合使用习惯，因此只能重载为友元

istream& operator>>(istream& steam, Vec2D& v1)
{
	// TODO: 在此处插入 return 语句
	steam >> v1[0] >> v1[1];
	return steam;
}

代码示例

通过运算符重载实现一个向量类Vec2D，可以使以下测试代码编译通过。
#include <iostream>
#include "Vec2D.h"
using std::cout;
using std::endl;

int main() {
	// 创建向量对象
	Vec2D v1{ 3,5 }, v2{ 4,6 };

// 向量转为字符串
cout << "v1 = " << v1.toString() << endl;
cout << "v2 = " << v2.toString() << endl;
// 向量加法： 向量+向量，向量+数
Vec2D v3 = v1 + v2;
Vec2D v4 = v3 + 10.0;
cout << "v3 = " << v3.toString() << endl;
cout << "v4 = " << v4.toString() << endl;
// 向量减法，向量点积，向量数乘
Vec2D v5 = v2 - v1;
double v6 = v2 * v1;
Vec2D v7 = 2.1 * v3;
cout << "v2 - v1 = " << v5.toString() << endl;
cout << "v2 . v1 = " << v6 << endl;
cout << "v3 * 2.1 = " << (v3 * 2.1).toString() << endl;
cout << "2.1 * v3 = " << v7.toString() << endl;

Vec2D va1{ 10, 12 }, va2{ 1, 2 };
cout << " va1 += va2 : " << (va1 += va2).toString() << endl;
cout << " va1 -= va2 : " << (va1 -= va2).toString() << endl;
// 向量求负值
Vec2D v8 = v2.negative();
cout << "-v2 = " << (-v2).toString() << endl;
// 向量自增/自减
cout << "++v8 = " << (++v8).toString() << endl;
cout << "v8++ = " << (v8++).toString() << endl;
cout << "v8 = " << v8.toString() << endl;
cout << "--v2 = " << (--v2).toString() << endl;
// 读取或者修改向量元素
v1[0] = 31.1;
cout << "v1.x_ = " << v1[0] << endl;
cout << "v1.y_ = " << v1[1] << endl;
// v1[ 8 ] = 10.0;
// 向量的长度magnitude 和角度direction
cout << "v1.magnitude = " << v1.magnitude() << endl;
cout << "double(v1) = " << static_cast<double>(v1) << endl;
cout << "v1.direction = " << v1.direction() << endl;
// 比较两个向量
cout << "v1 compare v2 : " << v1.compareTo(v2) << endl;
cout << "Please input a Vec2D:";
Vec2D v9{};
std::cin >> v9; // operator>>(std::cin, v9);
cout << v9 << endl;
}

完整代码：

#define M_PI       3.14159265358979323846

#include <iostream>
#include <string>


using namespace std;

class Vec2D
{
private:
	double x = 0.000000;
	double y = 0.000000;
public:
	Vec2D(int a, int b)
		:x(a), y(b)
	{}
	Vec2D() {}
	string toString();

	//向量加法： 向量 + 向量，向量 + 数
	Vec2D operator+(const Vec2D& v1);
	Vec2D operator+(const double& a);

	// 向量减法，向量点积，向量数乘
	Vec2D operator-(const Vec2D& v1);
	double operator*(const Vec2D& v1);
	friend Vec2D& operator*(const double& a, Vec2D& v1);
	friend Vec2D operator*(Vec2D& v1, const double& a);

	//+=  -=
	Vec2D& operator+=(const Vec2D& v1);
	Vec2D& operator-=(const Vec2D& v1);

	// 向量求负值
	Vec2D negative();
	Vec2D operator-();

	// 向量自增/自减
	Vec2D& operator++();
	Vec2D& operator--();
	Vec2D operator++(int dummy);

	// 读取或者修改向量元素
	double& operator[](const int index);

	// 向量的长度magnitude 和角度direction
	double magnitude();
	explicit operator double()
	{
		return sqrt(x * x + y * y);
	}
	double direction();

	// 比较两个向量
	bool compareTo(Vec2D& v1);

	//重载>>和<<
	friend ostream& operator<<(ostream& steam, Vec2D& v1);
	friend istream& operator>>(istream& steam, Vec2D& v1);

};

int main()
{
	// 创建向量对象
	Vec2D v1{ 3,5 }, v2{ 4,6 };

	// 向量转为字符串
	cout << "v1 = " << v1.toString() << endl;
	cout << "v2 = " << v2.toString() << endl;
	// 向量加法： 向量+向量，向量+数
	Vec2D v3 = v1 + v2;
	Vec2D v4 = v3 + 10.0;
	cout << "v3 = " << v3.toString() << endl;
	cout << "v4 = " << v4.toString() << endl;
	// 向量减法，向量点积，向量数乘
	Vec2D v5 = v2 - v1;
	double v6 = v2 * v1;
	Vec2D v7 = 2.1 * v3;
	cout << "v2 - v1 = " << v5.toString() << endl;
	cout << "v2 . v1 = " << v6 << endl;
	cout << "v3 * 2.1 = " << (v3 * 2.1).toString() << endl;//设计成一个右值，不可赋值
	cout << "2.1 * v3 = " << v7.toString() << endl;

	Vec2D va1{ 10, 12 }, va2{ 1, 2 };
	cout << " va1 += va2 : " << (va1 += va2).toString() << endl;
	cout << " va1 -= va2 : " << (va1 -= va2).toString() << endl;
	// 向量求负值
	Vec2D v8 = v2.negative();
	cout << "-v2 = " << (-v2).toString() << endl;
	// 向量自增/自减
	cout << "++v8 = " << (++v8).toString() << endl;
	cout << "v8++ = " << (v8++).toString() << endl; //这条语句执行完了之后再执行++操作
	cout << "v8 = " << v8.toString() << endl;
	cout << "--v2 = " << (--v2).toString() << endl;
	// 读取或者修改向量元素
	v1[0] = 31.1;
	cout << "v1.x_ = " << v1[0] << endl;
	cout << "v1.y_ = " << v1[1] << endl;
	// v1[ 8 ] = 10.0;
	// 向量的长度magnitude 和角度direction
	cout << "v1.magnitude = " << v1.magnitude() << endl;
	cout << "double(v1) = " << static_cast<double>(v1) << endl;
	cout << "v1.direction = " << v1.direction() << endl;

	// 比较两个向量
	cout << "v1 compare v2 : " << v1.compareTo(v2) << endl;
	cout << "Please input a Vec2D:";
	Vec2D v9{};
	std::cin >> v9; // operator>>(std::cin, v9);
	cout << v9 << endl;

	return 0;
}

string Vec2D::toString()
{
	string tmp;
	tmp = "(" + to_string(x) + "," + to_string(y) + ")";
	return tmp;
}

Vec2D Vec2D::operator+(const Vec2D& v1)
{
	Vec2D v3{ 0,0 };
	v3.x = this->x + v1.x;
	v3.y = this->y + v1.y;
	return v3;
}

Vec2D Vec2D::operator+(const double& a)
{
	Vec2D v4{ 0,0 };
	v4.x = this->x + a;
	v4.y = this->y + a;
	return v4;
}

Vec2D Vec2D::operator-(const Vec2D& v1)
{
	Vec2D v5{ 0,0 };
	v5.x = this->x - v1.x;
	v5.y = this->y - v1.y;
	return v5;
}

double Vec2D::operator*(const Vec2D& v1)
{
	return x * v1.x + y * v1.y;
}

Vec2D& operator*(const double& a, Vec2D& v1)
{
	Vec2D tmp(0, 0);
	tmp.x = a * v1.x;
	tmp.y = a * v1.y;
	return tmp;
}

Vec2D operator*(Vec2D& v1, const double& a)
{
	Vec2D tmp(0, 0);
	tmp.x = v1.x * a;
	tmp.y = v1.y * a;
	return tmp;
}


Vec2D& Vec2D::operator+=(const Vec2D& v1)
{
	x = this->x + v1.x;
	y = this->y + v1.y;
	return *this;
}

Vec2D& Vec2D::operator-=(const Vec2D& v1)
{

	x = this->x - v1.x;
	y = this->y - v1.y;
	return *this;
}

Vec2D Vec2D::negative()
{
	Vec2D tmp(0, 0);
	tmp.x = -x;
	tmp.y = -y;
	return tmp;
}

Vec2D Vec2D::operator-()
{
	Vec2D tmp(0, 0);
	tmp.x = -x;
	tmp.y = -y;
	return tmp;
}

Vec2D& Vec2D::operator++()
{
	x++;
	y++;
	return *this;
}

Vec2D& Vec2D::operator--()
{
	x--;
	y--;
	return *this;
}

Vec2D Vec2D::operator++(int dummy)
{
	Vec2D tmp(0, 0);
	//先把值给赋了，然后在执行本对象的自增操作
	tmp.x = x;
	tmp.y = y;
	x++;
	y++;
	//返回临时对象
	return tmp;
}


//能被赋值，肯定是一个左值，可引用
double& Vec2D::operator[](const int index)
{
	if (index == 0)return x;
	else if (index == 1)return y;
	else cout << "检索超过范围" << endl;
}

double Vec2D::magnitude()
{
	return sqrt(x * x + y * y);
}

double Vec2D::direction()
{
	double tmp = y / (this->magnitude());
	tmp = asin(tmp);
	return tmp;
}

bool Vec2D::compareTo(Vec2D& v1)
{
	if (this->magnitude() > v1.magnitude())return true;
	return false;
}

ostream& operator<<(ostream& steam, Vec2D& v1)
{
	// TODO: 在此处插入 return 语句
	steam << "(" << v1[0] << "，" << v1[1] << ")";
	return steam;
}

istream& operator>>(istream& steam, Vec2D& v1)
{
	// TODO: 在此处插入 return 语句
	steam >> v1[0] >> v1[1];
	return steam;
}
关系运算符重载
ZrZrZr666666的博客
04-06 254
重载关系运算符，可以让两个自定义类行对象进行比较 #include<iostream> using namespace std; class Person { public: Person(string name, int age) { m_Name = name; m_Age = age; } //重载关系运算符 bool operator== (Person...
C++的运算符重载
热门推荐
很不错的 blog
08-31 15万+
　　C++中预定义的运算符的操作对象只能是基本数据类型。但实际上，对于许多用户自定义类型（例如类），也需要类似的运算操作。这时就必须在C++中重新定义这些运算符，赋予已有运算符新的功能，使它能够用于特定类型执行特定的操作。运算符重载的实质是函数重载，它提供了C++的可扩展性，也是C++最吸引人的特性之一。 　　运算符重载是通过创建运算符函数实现的，运算符函数定义了重载的运算符将要进
运算符重载，两种常见运算符重载（加号运算符重载，左移运算符重载）
最新发布
m0_57094953的博客
08-25 726
实现运算符重载其实就是写一个函数，只不过这个函数的函数名是关键字operator后面跟上你要重载的运算符号，然后返回值类型是我们实际情况需要的返回值类型，比如我们重载要计算的是int类型，那么两个int类型相加肯定还是int类型返回值就写int类型，如果是Person类型那么两个Person类型相加返回值肯定是Person类型，然后再函数体中实现如何运算。
类的重载，隐含的this，运算符重载
SkinWhite的博客
10-05 1080
1.类：是c++中最重要的特征。              类的定义：用关键字class +类名。           类和对象：类是框架，不是具体的实例，而对象则是具体的实例化体现。
实验7 多态性和运算符重载.doc
12-20
"实验7 多态性和运算符重载" 多态性是指类族中具有相似功能的不同函数使用同一名称来实现，从而可以使用相同的调用方式来调用这些具有不同功能的同名函数。C++中的多态的实现形式包括函数重载、运算符重载、虚函数...
C++实践分数类中运算符重载的方法参考
01-21
【项目-分数类中的运算符重载】 （1）实现分数类中的运算符重载，在分数类中可以完成分数的加减乘除（运算后再化简）、比较（6种关系）的运算。 class CFraction { private: int nume; // 分子 int deno; // ...
复数运算符重载
03-26
在C#编程语言中，运算符重载是一种特殊的技术，允许程序员为自定义类型赋予标准运算符的新含义。当我们创建一个表示复数的类时，为了使得复数的加法、减法、乘法和除法等操作直观易用，就需要重载相应的运算符。复数...
详解C++编程中的单目运算符重载与双目运算符重载
01-20
C++单目运算符重载 单目运算符只有一个操作数，如!a，-b，&c，*p，还有最常用的++i和–i等。重载单目运算符的方法与重载双目运算符的方法是类似的。但由于单目运算符只有一个操作数，因此运算符重载函数只有一个参数...
C++实验报告实验七-运算符重载
03-14
### C++实验报告实验七-运算符重载 #### 实验目的 本次实验的主要目标是通过实际编程加深对C++中运算符重载的理解和应用。具体包括： 1. **编写程序熟悉运算符重载函数的定义和使用**：通过实践操作理解如何...
重载关系运算符
weixin_44540140的博客
05-15 1135
在C++中,运算符是可以重载的,本次讲解的是如何重载关系运算符,具体想实现的效果为比较同一个类的不同对象是否相等 想要比较类就要先创建类 class Person { public: Person(string name,int age) : m_Name(name) , m_Age(age) { } string m_Name; int m_Age; }; 创建一个名为Person的类,在声明为公共的区域中,创建两个值,一个是string类型的名称,另一个是int
运算符重载——关系运算符重载
k909397116的博客
05-28 837
写在前面： 1）本篇涉及内容： 关系运算符重载的应用场景 实现关系运算符重载的代码 2）关系运算符包含：<,>,==,!= 应用场景： 类中实现关系运算符重载，则可以实现自定义数据类型之间的比较，比较内容根据需求来. C++的类中重载“==”就相当于Java的类中重写equals方法 实现关系运算符重载： class Person { public: Person(int m_Age, string name) : m_Age(m_Age), name(name) {}
运算符重载的两种方法
一路向北
02-10 8131
运算符重载可以通过两种方法来实现，用成员函数或者友元函数重载运算符。 在本文章中，有两个重要的内容： 第一个： 前置++ 和 后置++重载，后置++通过一个占位符来标明。 第二个： 单目运算符重载时，当作为成员函数时，操作数通过this指针隐式传递，不用在函数参数表明，而友元函数需要。双目运算符重载时，当作为成员函数时，左操作数通过this指针隐式传递，只需要声明一个参数就可以了，而友元...
C++关系运算符重载
Cristina的博客
11-28 1239
C++关系运算符重载 为什么重载关系运算符？ 因为要直接对比类中的对象。 重载关系运算符应该在哪里？ 由于是对比类中的对象，而每个类应该是不一样的，所以重载关系运算符定义应该在类中。 如何定义关系运算符 众所周知，关系运算符就是true flase两种，所以，返回值类型应该是bool类型。 #include<iostream> #include<string> using namespace std; class Person { public: Person(s
关系运算符重载（＞,＜,==,!=）
m0_53157173的博客
02-01 683
关系运算符重载 #include<iostream> using namespace std; class wood { public: int num; int height; //==运算符重载 bool operator==(wood w) { if (num == w.num && height == w.height) { return true; } return false; } //!=运算符重载 bool operator!
C++重载之重载关系运算符
qq_45528961的博客
01-29 509
函数中，不会修改另一个超女对象的任何数据，加上const约束 运算符重载函数的返回值要和运算符本身的含义一致，关系运算表达式的结果是bool型，所以这个函数的返回值也是bool型。重载关系运算符（==，！=，>, >=,
C++运算符重载详解
"C++编程技术中的运算符重载部分，主要介绍了运算符重载的概念、方法、规则以及如何重载不同类型的运算符，包括作为成员函数和友元函数的重载，以及重载单目、双目运算符和流插入、流提取运算符等。" 在C++编程中，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值