运算符重载（1）

最新推荐文章于 2024-11-09 20:38:27 发布

校羽干

最新推荐文章于 2024-11-09 20:38:27 发布

阅读量147

点赞数

文章标签： c++ 蓝桥杯开发语言

本文链接：https://blog.csdn.net/fx2278642759/article/details/124915133

版权

这篇博客介绍了C++中的运算符重载、成员函数重载和非成员函数重载的概念及实现。通过示例展示了如何使用运算符重载实现复数类的加法，并探讨了运算符重载的规则，强调了不应滥用重载，只有当提高代码可读性和可维护性时才应考虑重载。同时，讨论了成员函数和友元函数在重载中的角色及其适用场景。

摘要由CSDN通过智能技术生成

1）运算符重载

2)成员函数重载

3）非成员函数重载

4）运算符重载规则

1）运算符重载

运算符重载允许把标准运算符（如+、-、*、/、<、>)等应用于自定义数据类型的对象。

直观自然，可以提高程序的可读性。

体现了C++的可扩充性。

运算符重载仅仅只是语法上的方便，它是另一种函数调用的方式。

运算符重载，本质上是函数重载

不要滥用重载、因为它只是语法上的方便，所以只有载涉及的代码更容易写、尤其是更易读时才有必要重载。

#ifndef _COMPLEX_H_
#define _COMPLEX_H_

class Complex
{
public:
	Complex(int real, int imag);
	Complex(void);
	~Complex(void);
	Complex& Add(const Complex& other);
	void Display() const;

private:
	int real_;
	int imag_;

};

#endif // !_COMPLEX_H_

#include "Complex.h"
#include <iostream>
using namespace std;

Complex::Complex(int real, int imag) :real_(real), imag_(imag)
{


}
Complex& Complex::Add(const Complex& other)
{
	real_ += other.real_;
	imag_ += other.imag_;
	return *this;
}
void Complex::Display() const
{
	cout << real_ << "+" << imag_ << "i" << endl;
}
Complex::Complex(void)
{


}
Complex::~Complex(void)
{


}

#include <iostream>
#include "Complex.h"
using namespace std;

int main(void)
{
	Complex c1(3,5);
	Complex c2(4,6);
	c1.Add(c2);
	c1.Display();

	return 0;
}

2)成员函数重载

成员函数原型的格式：

函数类型 operator 运算符（参数表）；

成员函数定义的格式：

函数类型类名：：operator 运算符（参数表）{

函数体；

}；

#ifndef _COMPLEX_H_
#define _COMPLEX_H_

class Complex
{
public:
	Complex(int real, int imag);
	Complex(void);
	~Complex(void);
	Complex& Add(const Complex& other);
	void Display() const;

	Complex operator+(const Complex& other);

private:
	int real_;
	int imag_;

};

#endif // !_COMPLEX_H_

#include "Complex.h"
#include <iostream>
using namespace std;

Complex::Complex(int real, int imag) :real_(real), imag_(imag)
{


}
Complex& Complex::Add(const Complex& other)
{
	real_ += other.real_;
	imag_ += other.imag_;
	return *this;
}
void Complex::Display() const
{
	cout << real_ << "+" << imag_ << "i" << endl;
}
Complex::Complex(void)
{


}
Complex::~Complex(void)
{


}
Complex Complex::operator+(const Complex& other)
{
	int r = real_ + other.real_;
	int i = imag_ + other.imag_;

	return Complex(r,i);

}

#include <iostream>
#include "Complex.h"
using namespace std;

int main(void)
{
	Complex c1(3,5);
	Complex c2(4,6);
	//c1.Add(c2);
	//c1.Display();

	Complex c3 = c1 + c2;  //等价于c1.operator(c2);
	//Complex c3 = c1.operator +(c2);  //和上面的结果一样。
	c1.Display();
	c2.Display();
	c3.Display();

	return 0;
}

3）非成员函数重载

友元函数原型的格式：

friend 函数类型 operator 运算符（参数表）；

友元函数定义的格式：

friend 函数类型类名：：operator 运算符（参数表）{

函数体；

}；

#ifndef _COMPLEX_H_
#define _COMPLEX_H_

class Complex
{
public:
	Complex(int real, int imag);
	Complex(void);
	~Complex(void);
	Complex& Add(const Complex& other);
	void Display() const;

	//Complex operator+(const Complex& other);
	friend Complex operator+(const Complex& c1, Complex& c2);

private:
	int real_;
	int imag_;

};

#endif // !_COMPLEX_H_

#include "Complex.h"
#include <iostream>
using namespace std;

Complex::Complex(int real, int imag) :real_(real), imag_(imag)
{


}
Complex& Complex::Add(const Complex& other)
{
	real_ += other.real_;
	imag_ += other.imag_;
	return *this;
}
void Complex::Display() const
{
	cout << real_ << "+" << imag_ << "i" << endl;
}
Complex::Complex(void)
{


}
Complex::~Complex(void)
{


}
/*Complex Complex::operator+(const Complex& other)
{
	int r = real_ + other.real_;
	int i = imag_ + other.imag_;

	return Complex(r,i);

}*/
 Complex operator+(const Complex& c1, Complex& c2)
{
	 int r =c1.real_ + c2.real_;
	 int i = c1.imag_ + c2.imag_;

	 return Complex(r, i);
}

#include <iostream>
#include "Complex.h"
using namespace std;

int main(void)
{
	Complex c1(3,5);
	Complex c2(4,6);
	//c1.Add(c2);
	//c1.Display();

	Complex c3 = c1 + c2;  //等价于c1.operator(c2);
	//Complex c3 = c1.operator +(c2);  //和上面的结果一样。
	c1.Display();
	c2.Display();
	c3.Display();

	return 0;
}

4）运算符重载规则

运算符重载不允许发明新的运算符。

不能改变运算符操作对象的个数。

运算符被重载后，其优先级和结合性不会改变。

不能重载的运算符：