c++运算符重载（C++运算符重载）

本篇文章给大家谈谈c++运算符重载，以及C++运算符重载对应的知识点，希望对各位有所帮助，不要忘了收藏本站喔。

本文目录一览：

• 1、c++中的运算符重载主要用来做什么？
• 2、C++运算符重载是什么意思
• 3、c++的所有运算符都可以重载吗？
• 4、什么是C++重载？
• 5、C++中如何自定义重载运算符
• 6、c++运算符重载问题

c++中的运算符重载主要用来做什么？

主要是用来使对象之间可以做慎并睁运算操作的.

比如,你定义了一个类的对象a而这个对象中有一个数据,又定义了一个b对象也有一个数据,你须要使用a+b来计算这两个对象中数据的合,就须要运算符重载.

运算符重载不光是可以重载四则运算的.也可以重载　[]下标运算符, 蔽迟输入输出运算符等等.

运算符重载主要的用途只是为了让运算符其前后跟后的对象可以直接像对宽岁象内的数据一样运算

C++运算符重载是什么意思

所谓重载，就是重新赋予新的含义。函数重载就是对一个已有的函数赋予新的含义，使之实现新功能，因此，一个函数名就可以用来代表不同功能的函数，也就是”一名多用”。

运算符也可以重载。实际上，我们已经在不知不觉之中使用了运算符重载。例如，大

家都

已习惯于用加法运算符”+”对整数、单精度数和双精度数进行加法运算，如5+8，

5.8

+3.67等，其实计算机对整数、单精度数和双精度数的加法操作过程是很不相同的，

但由于C++已经对运算符”消茄+”进行了重载，所以就能适用于int,

float,

doUble类型的运算。

又如”姿念“是C++的位运算中的位移运算符（左移），但在输出操作中又是与流对

象cout

配合使用的流插入运算符，”“也是位移运算符(右移），但在输入操作中又是与流对象

cin

配合使用的流提取运算符。这就是运算符重载(operator

overloading)。C++系统对”“和”“进行了重载，用户在不同的场合下使用它们时，作用是不同

的。对”“和”拿册察“的重载处理是放在头文件stream中的。因此，如果要在程序中用”“和””作流插入运算符和流提取运算符，必须在本文件模块中包含头文件stream(当然还应当包括”using

namespace

std“)。

在C++中不能在程序中直接用运算符”+”对复数进行相加运算。用户必须自己设法实现复数相加。例如用户可以通过定义一个专门的函数来实现复数相加。

[img]

c++的所有运算符都可以重载吗？

大多数C++运算符可以兆冲重载。运算符重载是一种形式的C++多态。运算符重载将重载的概念扩展到运算符上，允许赋予C++运算符多种含义。

单目运算符重载：

单目运算符只有一个操作数，如!a，-b，c，*p，还有最常用的++i和--i等。由于单目运算符只有一个操作数，因此运算符重载函数只有一个参数，如果运算符重载函数作为成员函数，则还可省略此参数。

下面以自增运算符”++“为例，介绍单目运算符的重载。

[例] 有一个Time类，包含数据成员minute(分)和sec(秒)，模拟秒表，每次走一秒，满60秒进一分钟，此时秒又从0开始算。要求输出分和秒的值。

可以看到：在程序中对运算符“++”进行了重载，使它能用于Time类对象。“++”和“--”运算符有两种使用方式，前置自增运算符和后置自增运算符

针对“++”和“--”这一特点，C++约定，在自增(自减)运算符重载函数中，增加一个int型形参，就是后置自增(自减)运算符函数。

双目运算符重载：

双目运算符(或称二元运算符)是C++中最常用的运算符。双目运算符有两个操作数，通常在运算符的左右两侧，如3+5，a=b，i10等。在重载双目运算符时，不言而喻在函数中应液猜陪该有两个参数。

[例] 定义一个字符串类String，用来存放不定长的字符串，重载运算符“==”、“”和“”，用于两个字符串的等于、小于和大于的比较运算。

有了这个基础后，再增加其他必要的内容。现在增加对运算符重载的部分。为便于编写和调试，先重载一个运算符“”。程序如下：

程序运行结果为1。

这只是一个并不很完善的程序，但是，已经完成了实质性的工作了，运算符重载成功了闹蠢。其他两个运算符的重载如法炮制即可。

什么是C++重载？

C++重载是C语言中的一种函数表现方式，即重载函数。

重载函数是函数的一种特殊情况，为方纤枯便使用，C++允许在同一范围中声明几个功能类似的同名函数，但是这些同名函数的形式参数（指参数的个数、类型或者顺序）必须不同。

也就是说用同一个运算符完成不同的运算功能。这就是重载函数。重载函数常用来实现功能类似而所处理的余竖扰数据类型不同的问题，不能只有函数返回值类型不同。

扩展资料：

C++运算符重载的相关规定如下：

1、不能改变运算符的优先级。

2、不能改变运算符的结合型。

3、默认参数不能和重载的运算符一起使用。

4、不能改变运算符的操作数的个数。

5、不能创建新的运算符，只有已有运算符可以被重载。

6、运算符作用于C++内部提供的竖旦数据类型时，原来含义保持不变。

参考资料来源：百度百科：重载函数

C++中如何自定义重载运算符

C++中预定义的运算符其运算对象只能是基本数据类型，而不适用于用户自定义类型（如类）.

// 同上，内置的运算符 只能应用于内置的数据类型 ...比如 int char double .等等。

(一) C++不允许用户自己定义新的运算符，只能对已有的C++运算符进行重载。

// 就是说只能重载内置的 + - * / 等运算符，不能自己创造运算符计算。 。

（二） C++允许重载的运算符C++中绝大碧友部分的运算符允许重载.

不能重载的运算符只有5个：

(1) 成员访问运算符.

(2) 作用域悔穗槐运算符∷

(3) 条件运算符?:

(4) 成员指针运算符*

(5) 编译预处理命令的开始符号#

(三) 重载不能改变运算符运算对象(即操作数)的个数。

// 不能改变运算符运算对象， 比如+法运算符，那么它有两个操作数 ..当我们重载它的时候 也只能有两个操作数 。

(四) 重载不能改变运算符的优先级别。

// 重载完之后并不能改变它的优先级别，比如 +号， 无论你怎么设计重载函数. 它永远不可能比()的优先级高......

(五) 重载运算符的函数不能有默认的参数，否则就改变了运算符参数的个数，与前面第(3)点矛盾。

// 于上面3..同。

(六) 重载的运算符必须和用户定义的自定义类型的对象一起使用，其参数至少应有一个是类对象(或类对象的引用)。也就是说，参数不能全部是C++的标准类型，以防止用户修改用于标准类型数据的运算符的性质。

// 重载的参数不能全部是C++内置数据类型。 至少要有一个是自定义类型。因为如果我们定义的是两个内置的类型 就会跟系统所定义的冲突。 因为当我们使用内置的运算符时，那么编译器其实也是调用的一个重载运算符进行计算。这是编译器自动添加的。 如果我们也定义的相同 那么肯定会产生冲突。

(七) 用于类对象的运算符一般必须重载，但有两个例外，运算符“=”和“”不必用户重载。

① 赋值运算符(=)可以用于每一个类对象，可以利用它在同类对象之间相互赋值。

② 地址运算符也不必重载，它能返回类对象在内存中的起始地址。

// 前面已经说过，C++内置运算符只能计算内置的数据类型 。所以当我们要使用自定义类型时 就必须要进行重载..

总之，当C++语言原有的一个运算符被重载之后，它原先所具有的语义并没有消失，只相当于针对一个特定的类定义了一个新的运算符。

运算符重载可以使用成员函数和友元函数两种形式。可以参考以下的经验：

(1)只能使用成员函数重载的运算符有：=、()、[]、-、new、delete。

(2)单目运算符最好重载为成员函数。

(3) 对于复合的赋值运算符如+=、-=、*=、/=、=、!=、~=、%=、=、=建议重载为成员函数。

(4) 对于其它运算符，建议重载为友元函数。

运算符重载的方法是定义一个重载运算符的函数，在需要执行被重载的运算符时，系统就自动调用该函数，以实现相应的运算。也就是说，运算符重载是通过定族举义函数实现的。运算符重载实质上是函数的重载。重载运算符的函数一般格式如下：

函数类型 operator 运算符名称 (形参表列)

{

对运算符的重载处理

}

重载为类成员函数时参数个数=原操作数个数-1

（后置++、--除外）

// 当重载为类成员函数时，参数个数等于原来的操作数-1 ..比如 对象a +对象b ..我们重载的时候需要两个操作数 a 和b 但我们传递过去一个就可以了 ， 比如 a+b 我们只需要把b传递过去就可以了。因为当调用重载运算符时 就是a调用的重载运算符，那么它就是当前对象 它就是这时的this 指针 ..而且类成员函数只能使用两个类中成员...

重载为友元函数时 参数个数=原操作数个数，且至少应该有一个自定义类型的形参。

//与上面没多大区别，但它却可以调用非类中对象.. 比如调用一个对象a+1 ..注意的是即使定义为友元函数，它的操作数也必须有一个为自定义类型。

看一个实例：

#includeiostream

using namespace std;

class complex //复数类声明

{

public: //外部接口

complex(double r=0.0,double i=0.0)

{

real=r;

imag=i;

} //构造函数

complex operator + (complex c2); //+重载为成员函数

complex operator - (complex c2); //-重载为成员函数

void display(); //输出显示复数

private: //私有数据成员

double real; //复数实部

double imag; //复数虚部

};

complex complex::operator +(complex c2) //重载函数实现

{

complex c;

c.real=real+c2.real;

c.imag=imag+c2.imag;

return complex(c.real,c.imag);

}

complex complex::operator -(complex c2) //重载函数实现

{

complex c;

c.real=real-c2.real;

c.imag=imag-c2.imag;

return complex(c.real,c.imag);

}

void complex::display()

{ cout"("real","imag"i"")"endl; }

int main() //主函数

{

complex c1(5,4),c2(2,10),c3; //声明复数类的对象

cout"c1="; c1.display();

cout"c2="; c2.display();

c3=c1-c2; //使用重载运算符完成复数减法

cout"c3=c1-c2=";

c3.display();

c3=c1+c2; //使用重载运算符完成复数加法

cout"c3=c1+c2=";

c3.display();

system("pause");

return 0;

}

程序输出的结果为：

c1=(5,4i)

c2=(2,10i)

c3=c1-c2=(3,-6i)

c3=c1+c2=(7,14i)

通过代码我们可以看出： 定义了两个成员函数重载运算符..重载了+ 和- . 当我们使用这个类的两个成员进行相加的或者相减的时候就会自动调用重载的运算符..使用我们在重载的运算符中所定义的操作。那我们可以看到，在进行+或者-的时候是把两个对象中保存的复数的值进行加减 然后返回了。 要注意的是并不是+号和减号被完全改变了，而只是这个类中的对象在进行+ -操作的时候才会调用重载.

我们来测试一下; 我们在main()函数中再定义三个变量 ，int a=5,b=3,c; c=a-b ; 然后再输出c的值 ，我们发现输出为2 . .这也证明了我们所定义的重载运算符并没有改变它原来的功能..而是赋予了它多重的含义..

那我们再来看下运算符重载在友元函数中的使用。

我们只需要将complex complex::operator +(complex c2) //重载函数实现

{

complex c;

c.real=real+c2.real; // real 代表 this-real 其实就是代表传递进来的当前对象.

c.imag=imag+c2.imag;

return complex(c.real,c.imag);

}

这段代码 修改一下... 改为 complex friend complex::operator +(complex c2 complex c3)

那么同样也可以完成相同的功能..而且还更容易扩充..因为从上面得知..重载的运算符必须和用户定义的自定义类型的对象一起使用. 也就是说至少有一个自定义类型..或者是它的引用..如果我们使用成员运算符重载的话只能使用类中的对象成员..而使用友元运算符重载那么我们则可以使用类外的数据..当我们需要使用的时候直接修改为 complex friend complex::operator +(complex c2 int a) 如这样的形式就可以了。

c++运算符重载问题

代码如下：

#include iostream

using namespace std;

class Matrix {

public:

Matrix(int m, int n, int val);

Matrix(const Matrix other);

int get(int m, int n) const;

void set(int m, int n, int val);

int*  operator[](int m) {

if (m  0 || m  _m) {

throw "无效的索引。";

}

return _data[m];

}

Matrix operator+(const Matrix matrix);

friend Matrix operator*(const Matrix m1, const Matrix m2);

Matrix operator++(int);

int m() const {

return this-_m;

}

int n() const {

return this-_n;

}

const int** data() const {

return (const int**)_data;

}

~Matrix();

private:

int _m;

int _n;

int **_data;

};

Matrix::Matrix(int m, int n, int val) {

if (m  1) {

throw "行数不能小于1。";

}

if (n  1) 银轮{

throw "列数不能小于1。";

}

this-_m = m;

this-_n = n;

this-_data = new int*[m];

for (int i = 0; i  m; i++) {

this-_data[i] = new int[n];

for (int j = 0; j  n; j++) {

_data[i][j] = val;

}

}

}

Matrix::Matrix(const Matrix other) {

_m = other._m;

_n = other._n;

this-_data = new int*[_m];

for (int i = 0; i  _m; i++) {

this-_data[i] = new int[_n];

for (int j = 0; j  _n; j++) {

_data[i][j] = other._data[i][j];

}

}

}

int Matrix::get(int m, int n) const {

if (m  0 || m  _m || n  0 || n  _n) {

throw "无效的索引。";

}

return _data[m][n];

}

void Matrix::set(int m, int n, int val) {

if (m  0 || m  _m || n  0 || n  _n) {

throw "无效的索引。";

}

_data[m][n] = val;

}

Matrix Matrix::operator+(const Matrix matrix) {

if (_m != matrix._m || _n != matrix._n) {

throw "不满足矩阵加法规则。";

}

Matrix result(_m, _n, 0);

for (int i = 0; i  _m; i++) {

for (int j = 0; j  _n; j++) {

result.set(i, j, this-get(i, j) + matrix.get(i, j));

}

}

return result;

}

Matrix Matrix::operator++(int) {

Matrix result(*this);

for (int i = 0; i  _m; i++) {

for (int j = 0; j  _n; j++) {

_data[i][j]++;

}

}

return result;

}

Matrix::~Matrix() {

for (int 扮顷i = 0; i  this-_m; i++) {

delete[] this-_data[i];

}

delete[] this-_data;

}

Matrix operator*(const Matrix m1, const Matrix m2) {

if (m1._n != m2._m) {

throw "不满锋缺信足矩阵乘法规则。";

}

Matrix result(m1._m, m2._n, 0);

for (int i = 0; i  result._m; i++) {

for (int j = 0; j  result._n; j++) {

int value = 0;

for (int k = 0; k  m1._n; k++) {

value += m1.get(i, k) * m2.get(k, j);

}

result.set(i, j,  value);

}

}

return result;

}

void print(const Matrix matrix) {

for (int i = 0; i  matrix.m(); i++) {

for (int j = 0; j  matrix.n(); j++) {

cout  matrix.get(i, j)  " ";

}

cout  endl;

}

}

int main()

{

try {

Matrix a(3, 2, 5);

Matrix b(3, 2, 4);

print(a);

print(b);

Matrix c = a + b;

print(c);

cout  "----------------------"  endl;

Matrix d(3, 2, 5);

Matrix e(2, 4, 4);

print(d);

print(e);

Matrix f = d * e;

print(f);

cout  "----------------------"  endl;

Matrix g = f++;

g[0][0] = 85;

print(g);

print(f);

}

catch (const char * msg) {

cerr  msg  endl;

}

system("pause");

return 0;

}

关于c++运算符重载和C++运算符重载的介绍到此就结束了，不知道你从中找到你需要的信息了吗 ？如果你还想了解更多这方面的信息，记得收藏关注本站。