C++运算符重载怎么定义和使用

蜗牛互联网技术资讯2023-04-19470

这篇文章主要介绍“C++运算符重载怎么定义和使用”的相关知识，小编通过实际案例向大家展示操作过程，操作方法简单快捷，实用性强，希望这篇“C++运算符重载怎么定义和使用”文章能帮助大家解决问题。

1、运算符重载定义

正常来说，我们一般使用的运算符是对基本的数据类型进行操作，但是在C++中有了对象，导致对象无法通过运算符进行运算，故引入了运算符重载即需要重新的定义这些运算符，赋予已有运算符新的功能，使它能够用于特定类型执行特定的操作。运算符重载的实质是函数重载，它提供了C++的可扩展性。

运算符重载是通过创建运算符函数实现的，运算符函数定义了重载的运算符将要进行的操作。运算符函数的定义与其他函数的定义类似，唯一的区别是运算符函数的函数名是由关键字operator和其后要重载的运算符符号构成的。运算符函数定义的一般格式如下：

<返回类型说明符> operator <运算符符号>(<参数表>)
{
<函数体>
}

其中，“返回类型说明符”指出重载运算符的返回值类型，operator是定义运算符重载函数的关键字，“运算符符号”指出要重载的运算符名字，是C++中可重载的运算符，比如要重载加法运算符，这里直接写“+”即可，“参数表”指出重载运算符所需要的参数及其类型。可以看出，运算符重载是一种形式C++多态的体现。

例如，使用“+”将两个对象相加，编译器将根据操作数的数目和类型决定使用哪种加法定义，这样可以让代码看起来更加自然。

//正常情况下两个数组的数相加
for(int i= 0; i<10; i++)
    c[i] = a[i] + b[i];
//可以通过定义一个数组的类，重载“+”运算符后
//隐藏了内部机制，并强调了实质
arry operator+(arry p,arry q)
{
   arry t;
    for(int i= 0; i<10; i++)  //c = a + b;
    {
      t.a[i]=p.a[i]+q.a[i];
    }
    return t;
}

运算符重载就是对已有的运算符重新进行定义，赋予其另一种功能，以达到适应不同的数据类型。运算符重载不能改变它本来的寓意(也就是加法不能变更为减法)，运算符重载只是一种 “语法上的方便” ，它只是一种函数调用的方式。

2、作为成员函数进行重载

我们就以“+”运算符重载举例：

#include <iostream>
using namespace std;
class addfloat
{
public:
    addfloat(float p);
    //声明运算符重载
    addfloat operator+(const addfloat &A) const;
    void show() const;
private:
    float m_p;
};
addfloat::addfloat(float p)
{
    m_p = p;
}
//作为类的成员函数实现运算符重载
addfloat addfloat::operator+(const addfloat &A) const
{
    addfloat B;
    B.m_p = this->m_p + A.m_p;
    return B;
}
void addfloat::show() const
{
    cout<<"输出结果是"<<m_p<<endl;
}


int main()
{
    addfloat m(5.1);
    addfloat n(1.5);
    addfloat t;
    t = m + n; //两个addfloat类对象相加:t = m.operator+(n);
    t.show();
    return 0;
}

运行结果为：

输出结果是6.6

从上面的例子可以看出，在addfloat类中对“+”运算符进行了重载，重载后可以对该类的对象进行加法运算。当运行 t = m + n时，编译器检测到“+”左边的m（“+”具有左结合性，所以先检测左边）是一个 addfloat类对象，就会调用成员函数 operator+()，将表达式转换成如下格式：

t = m.operator + (n);

表达式中m作为调用函数的对象，n作为函数的实参。

3、作为全局函数进行重载

对于之前的例子：t = m + n，m和n是作为addfloat类的对象进行相加的，使用成员函数 operator+()转换为了t = m.operator+(n)，如果n不是类的对象，而是一个常数，例如：

t = m + 5.2；那么可以转换t = m.operator+(5.2)；

但是如果m是一个常数时，即：t = 5.2 + n；则t = (5.2).operator + (n)这种转换是不允许的，编译器会报错，因为5.2不能作为类的对象调用运算符重载operator+()函数。

这种场景下针对“+”这种运算符作为类的成员函数进行重载是不可以的。运算符重载不仅仅可以通过类的成员函数来实现，也可以通过全局函数来实现。

我们需要将运算符重载的全局函数声明为友元函数，因为大多数时候重载运算符要访问类的私有数据，（当然也可以设置为非友元非类的成员函数，但是非友元又不是类的成员函数，是没有办法直接访问类的私有数据的），如果不声明为类的友元函数，而是通过在此函数中调用类的公有函数来访问私有数据会降低性能。所以一般都会设置为类的友元函数，这样我们就可以在此非成员函数中访问类中的数据了。

#include <iostream>
using namespace std;
class addfloat
{
public:
    addfloat(float p);
    //声明为友元函数
    friend addfloat operator+(const addfloat &A, const addfloat &B);
    void show() const;
private:
    float m_p;
};
addfloat::addfloat(float p)
{
    m_p = p;
}

void addfloat::show() const
{
    cout<<"输出结果是"<<m_p<<endl;
}

//作为全局函数进行重载
addfloat operator+(const addfloat &A, const addfloat &B)
{
    addfloat C;
    C.m_p = A.m_p + B.m_p;
    return C;
}

int main()
{
    addfloat m(5.1);
    addfloat n(1.5);
    addfloat t;
    t = m + n; //两个addfloat类对象相加:t = m.operator+(n);
    t.show();
    return 0;
}

由上述程序可以看出，运算符重载函数operator+()不是 addfloat类的成员函数，但是却用到了 addfloat类的 private 成员变量m_p，所以需要在 addfloat类中将operator+()函数声明为友元函数。

当运行t = m + n时，编译器检测到“+”两边都是addfloat类的对象，就会转换为类似下面的函数调用：

t = operator + (m, n);

因此，m和n都可以看作是函数的实参：

t = m + 5.2转换为 t = operator + (m, 5.2);

t = 5.2 + n转换为 t = operator + (5.2, n);

以全局函数的形式重载“+”，是为了保证“+”运算符的操作数能够被对称的处理；换句话说，常数在“+”左边和右边都是正确的；

因此，运算符左右两边都有操作对象时，且这两个操作对象可以互换，最好可以使用全局函数的形式重载，例如：+、-、*、/、==、!= ，这些符合运算符两边有操作对象的运算符。