10- 运算符重载

最新推荐文章于 2024-08-25 11:21:17 发布
最新推荐文章于 2024-08-25 11:21:17 发布
阅读量343 收藏
点赞数
分类专栏： # C++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/hxy1625309592/article/details/111874553
版权

1- 基本要求

C++预定义的运算符，只能用于基本数据类型的运算：整型、实型、字符型、逻辑型…+、-、*、/、%、^、&、~、!、|、=、<<>>、!=、

在数学上，两个复数可以直接进行+、-等运算。但在C++中，直接将+或-用于复数对象是不允许的。

2- 运算符重载定义

  • 运算符重载，就是对已有的运算符(C++中预定义的运算符)赋予多重的含义，使同一运算符作用于不同类型的数据时导致不同类型的行为。
  • 运算符重载的目的是：扩展C++中提供的运算符的适用范围，使之能作用于对象。同一个运算符，对不同类型的操作数，所发生的行为不同。

3- 运算符重载作用

赋予运算符自定义功能。

默认:常数+常数
比如对象+对象，默认情况下是不被允许的，当我们重载了+后，就可以实现对象相加了。
对象+常数，常数+对象重载函数，函数的两个参数在小括号内，运算符的两个参数在两侧。

4- 基本形式

  • 运算符重载的实质是函数重载
  • 可以重载为普通函数，也可以重载为成员函数 。
  • 把含运算符的表达式转换成对运算符函数的调用。
  • 把运算符的操作数转换成运算符函数的参数。运算符被多次重载时，根据实参的类型决定调用哪个运算符函数。
返回值类型 operator  运算符（形参表）
{
……
}

5- 运算符重载案列

5.1 无函数返回值
#include <iostream>
using namespace std;

class CStu
{
public:
    // 声明两个成员变量
	int nAge;
	double dScore;

    // 创建构造函数
	CStu()
	{
		nAge = 12;
		dScore = 12.12;
	}
};

//运算符重载
void operator+(CStu& st, int a)
{
	cout << (st.nAge + a) << endl;
}

void operator+(int a, CStu& st)
{
	cout << (st.nAge + a) << endl;
}

int main()
{
	
    // 声明两个对象
	CStu st1, 
		 st2;
    // + 
	int a = 13;
	a + 13;

	//st1 + st2;
	st1 + 12;
	12 + st2;

	return 0;
}
5. 2 带函数返回值
#include <iostream>
using namespace std;

class CStu
{
public:
	// 声明两个成员变量
	int nAge;
	double dScore;

	// 创建构造函数
	CStu()
	{
		nAge = 12;
		dScore = 12.12;
	}
};

//运算符重载
int  operator+(CStu& st, int a)
{
	return (st.nAge + a);
}

int main()
{
	// 声明两个对象
	CStu st1,
		st2;

	cout << (st1 + 12 + 13) << endl;

	return 0;
}
5.3 类外重载

左边是左参数，右边是右参数

#include <iostream>
using namespace std;

class CStu
{
public:
	int nAge;
	double dScore;

	CStu()
	{
		nAge = 12;
		dScore = 12.12;
	}
};

//运算符重载
int operator+(CStu& st, int a)
{
	return (st.nAge + a);
}

int operator+(int a, CStu& st)
{
	
	return (st.nAge + a);
}

CStu& operator+(CStu& st1, CStu& st)
{
	
	st1.nAge += st.nAge;
	return st1;
}

CStu& operator::(CStu& st1,int a)
{
	
	st1.nAge += st.nAge;
	return st1;
}

int main()
{
	CStu st1, //对象1
		st2; 
    
	// 输出结果
	cout << (st1 + 12 + 13 + (st2 + st2) + 23);
	
	return 0;
}
5.4 类内重载

默认左边是类的类型

#include <iostream>
using namespace std;

class CStu
{
public:
	int nAge;
	CStu()
	{
		nAge = 12;
	}

    // 类内重载
	int operator+(int a)  
	{
		return (this->nAge + a);
	}
};

// 类外重载
int operator+(int a, CStu& st)
{
	return (a - st.nAge);
}

int main()
{
	CStu st;
	cout << (st + 12) << endl;

	cout << (13 + st) << endl;

	return 0;
}

6 - 常见运算符

算术运算符

+ ,- ,* ,/ ,%

关系运算符

>= ,<= ,> ,< ,!= ,==

位运算符

>^ ,& ,I

逻辑运算符

>&&，||
6.1 二元运算符重载
#include <iostream>
using namespace std;

class CStu 
{
public:
	int nAge;
	CStu(int age)
	{
		nAge = age;
	}

	int operator >= (CStu& st2)
	{
		return (nAge >= st2.nAge);
	}

	int operator & (CStu& st2)
	{
		return (nAge & st2.nAge);
	}

	int operator && ( CStu& st2)
	{
		return (nAge && st2.nAge);
	}
};

int operator += (CStu& st1, CStu& st2)
{
	return (st1.nAge && st2.nAge);
}

int main()
{
	CStu st1(14); //st1.nage
	CStu st2(13);

	cout << (st1 >= st2);
	cout << (st1 && st2);


	system("pause");
	return 0;
}
6.1 一元运算符重载
#include <iostream>
using namespace std;

class CStu 
{
public:
	int nAge;
	CStu(int age)
	{
		nAge = age;
	}

    // 内重载
	int operator-()
	{
		return (-nAge);
	}
};

// 外重载
int operator!(CStu& st)
{
	return (!st.nAge);
}


int main()
{
	CStu st1(14); //st1.nage

	cout << (!st1);

	system("pause");
	return 0;
}
6.3 输出运算符重载

特点：

  • cout是一个对象
  • 参数1是ostream引用，参数2是对象的常引用
  • 返回值保证连续输出
  • 必须是类外
  • 类友元
#include <iostream>
using namespace std;

class CStu
{
private:
	int nAge;

public:
	CStu()
	{
		nAge = 12;
	}
	// 定义友元函数
	friend ostream& operator << (ostream& os, const CStu& st);

};

ostream& operator << (ostream& os, const CStu& st)
{
	os << st.nAge;
	return os;
}

int main()
{
    // 创建对象
	CStu st;
    // 输出对象
	cout << st << st << "kobe";
	return 0;
}
6.4 输入运算符重载

代码示例

#include <iostream>
using namespace std;

class CStu
{
private:
	int nAge;
	double dbHeight;
public:
	CStu()
	{
		nAge = 0;
		dbHeight = 0.0;
	}

	void Show()
	{
		cout << nAge << endl;
		cout << dbHeight << endl;
	}
	friend istream& operator >> (istream& ist, CStu& st);
};

istream& operator >> (istream& ist, CStu& st)
{
	ist >> st.nAge >> st.dbHeight;

	// 需要输入检测是否失败
	if (ist.fail())
	{
		st.nAge = 0;
		st.dbHeight = 0;
	}
	return ist;
}

int main()
{
    // 创建st对象
	CStu st;
	cin >> st;

	st.Show();
	return 0;
}
6.5 赋值运算符重载
#include <iostream>
using namespace std;

class CStu
{
private:
	int nAge;
	double dbHeight;
public:
	CStu()
	{
		nAge = 0;
		dbHeight = 0.0;
	}

	int operator=(int a)
	{
		nAge = a;
		return nAge;
	}

	int& operator+=( int a)
	{
		nAge = nAge + a;

		return nAge;
	}

};

/*

// 类外重载
int& operator+=(CStu& st1, int a)
{
	st1.nAge = st1.nAge + a;
	
	return st1.nAge;
}
*/


int main()
{	
	// 创建对象
	CStu st;
	int a = 111;

	cout << (st += a += 113);
    
	return 0;
}
6.6 下标运算符重载
#include <iostream>
using namespace std;

// 下标运算符:[ ]特点 返回引用 只能类内
class CStu
{
public:
	int a;
	int b;
	int c;
	double d;

	int nError;

	CStu()
	{
		a = 12;
		b = 23;
		c = 34;
		d = 45;
		nError = -1;
	}
	
    //返回指针
	int& operator[](int n) 
	{
		
		switch(n)
		{
		case 0:
			return &a;
		case 1:
			return &d;
		}
		return &nError;
	}
};



int main()
{
	CStu st; //st[1]
	cout << *(int *)st[0]; 
	cout << *(double *)st[1]; // void 没有确定的大小 //  ==》void* ==》
	*(double *)st[1] = 15;
	cout << *(double *)st[1];

	return 0;
}
6.7 自加自减运算符重载
#include <iostream>
using namespace std;

class CStu
{
public:
	int nAge;
	CStu()
	{
		nAge = 12;
	}

	int operator++()
	{
		nAge += 1;
		return nAge;
	}

	int operator--()
	{
		this->nAge -= 1;
		return nAge;
	}

	int operator++(int n) //int n 理解成一个标记
	{
		n = nAge; //
		nAge += 1;
		return n;
	}

};

/*
	// 类外++
int operator++(CStu& st)
{
	st.nAge += 1;
	return st.nAge;
}
*/


/*
	// 类外 --
int operator--(CStu& st)
{
	st.nAge -= 1;
	return st.nAge;
}
*/

// 后置 ++
int operator++(CStu& st, int n) //int n 理解成一个标记
{
	n = st.nAge; //
	st.nAge += 1;
	return n;
}

// 后置 --
int operator--(CStu& st, int n) //int n 理解成一个标记
{
	n = st.nAge; //
	st.nAge -= 1;
	return n;
}


int main()
{
	int a = 12;
	//int b = ++a; // b == 13

	//a++;
	int b = a++; //b == 12, a == 13

	CStu st;
	//cout << ++st;  //13
	//	cout << --st;  //12

	cout << st--;
	cout << st.nAge;
	
	return 0;
}

7- 重载类型转换

基本特点

  • 没有显示返回类型，但是要写返回值。
  • 没有参数。必须定义成类的成员函数。
  • 不应该改变对象的内容，所以是const函数。避免过度使用。
#include <iostream>
using namespace std;

class CStu
{
public:
	int a;
	double b;
	CStu()
	{
		a = 13;
		b = 12.12;
	}

	// 类型转换没有返回值
	operator int() const
	{
		return a;
	}

	operator double() const
	{
		return b;
	}
};

int main()
{
	// 创建对象
	CStu st;
	cout << int(st) << endl;
	cout << (double)st << st.b << endl;
	return 0;
}
guardwhy
关注
专栏目录
C++ 运算符重载
yh的博客
03-13 289
运算符重在是一种形式的C++多态，之前有学过C++是如何能够定义多个名称相同但是参数列表不同的函数的，这被称为函数重载或者函数多态。这种操作被用于不同的数据类型运用同名的函数来完成相同的基本操作。运算符重载将重载的概念扩展到运算符概念上，允许赋予C++运算符多种含义。实际上之前我们已经用过运算符重载，例如，将*运算符用于地址，将得到存储到这个地址中得值，当时将它用于两个数字时，得到...
C++实验报告实验七-运算符重载
03-14
### C++实验报告实验七-运算符重载 #### 实验目的 本次实验的主要目标是通过实际编程加深对C++中运算符重载的理解和应用。具体包括： 1. **编写程序熟悉运算符重载函数的定义和使用**：通过实践操作理解如何...
运算符重载
Mosu_的专栏
08-16 203
·c++预定义表示对数据的运算     ·+ - * / % ^ &amp; ~ ! | = &lt;&lt; &gt;&gt; != ......     ·只能用于基本的数据类型         ·整型 实型 字符型 逻辑型...... ·c++提供了数据抽象的手段     用户自己定义数据类型---类     ·调用类的成员函数---操作它的对象 ·类的成员函数---操作对象时，很不方便  ...
运算符重载，两种常见运算符重载（加号运算符重载，左移运算符重载）
最新发布
m0_57094953的博客
08-25 662
实现运算符重载其实就是写一个函数，只不过这个函数的函数名是关键字operator后面跟上你要重载的运算符号，然后返回值类型是我们实际情况需要的返回值类型，比如我们重载要计算的是int类型，那么两个int类型相加肯定还是int类型返回值就写int类型，如果是Person类型那么两个Person类型相加返回值肯定是Person类型，然后再函数体中实现如何运算。
操作符重载
nodeathphoenix的专栏
09-08 4938
在C++语言中，可以用关键字operator加上运算符来表示函数，叫做运算符重载。例如两个复数相加函数： Complex Add(const Complex &a, const Complex &b); 可以用运算符重载来表示： Complex operator +(const Complex &a, const Complex &b); 运算符与普通函数在调用时的不同之处
运算符的重载
m0_51918781的博客
07-21 378
运算符的重载
cpp代码-前置++，--，和后置++，--运算符重载
07-14
在C++编程语言中，运算符重载是面向对象特性的一部分，允许我们为自定义类型定义特定的行为。这里，我们将深入探讨前置`++`、后置`++`、前置`--`和后置`--`这四个增量和减量运算符的重载，并通过实例分析如何在`main...
面向对象程序设计语言C++---第5章-运算符重载.ppt
07-04
C++运算符重载 面向对象程序设计语言C++中的运算符重载是指在用户定义类型上重新定义普通运算符的含义，以达到扩展语言的能力。运算符重载允许用户在不同的上下文中对已存在的预定义运算符进行重新解释。 1.运算符...
C++实验11--运算符重载.html
05-25
C++实验11--运算符重载.html
C++ 重载运算符和重载函数
大西瓜不甜的博客
11-17 247
C++ 允许在同一作用域中的某个函数和运算符指定多个定义，分别称为函数重载和运算符重载。 重载声明是指一个与之前已经在该作用域内声明过的函数或方法具有相同名称的声明，但是它们的参数列表和定义（实现）不相同。 当您调用一个重载函数或重载运算符时，编译器通过把您所使用的参数类型与定义中的参数类型进行比较，决定选用最合适的定义。选择最合适的重载函数或重载运算符的过程，称为重载决策。 C++ 中的函数重载 在同一个作用域内，可以声明几个功能类似的同名函数，但是这些同名函数的形式参数（指参数的个数、类型或者顺
复数相乘--运算符重载
06-20
复数相乘涉及到实部和虚部分别进行运算，结果也是一个复数。在编程中，如果需要实现复数的运算，包括相乘，通常会涉及运算符重载，以便让程序员能够使用熟悉的符号（如 `*`）来进行操作。以下是如何在一些编程语言中（如C++）复数相乘并重载运算符的简单步骤： 1. 定义复数类：首先定义一个复数类，包含两个成员变量（通常是`real`和`imaginary`）表示实部和虚部。 ```cpp class Complex { public: double real; double imaginary; // 其他构造函数和相关方法 }; ``` 2. 运算符重载：为 `*` 运算符定义一个成员函数，用于执行复数相乘。 ```cpp Complex operator*(const Complex& other) const { double realPart = real * other.real - imaginary * other.imaginary; double imagPart = real * other.imaginary + imaginary * other.real; return Complex{realPart, imagPart}; } ``` 3. 使用示例：现在，你可以像这样使用复数的 `*` 运算符： ```cpp Complex a(1, 2); Complex b(3, 4); Complex c = a * b; // c的值将是(7, 10) ```
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值