阿坝州网站建设公司

初识C++05：运算符重载

运算符重载

运算符重载基础

函数重载（Function Overloading）可以让一个函数名有多种功能，在不同情况下进行不同的操作。运算符重载（Operator Overloading）也是一个道理，同一个运算符可以有不同的功能。

柯桥ssl适用于网站、小程序/APP、API接口等需要进行数据传输应用场景，ssl证书未来市场广阔！成为创新互联的ssl证书销售渠道，可以享受市场价格4-6折优惠！如果有意向欢迎电话联系或者加微信：18982081108（备注：SSL证书合作）期待与您的合作！

例子：用+号实现复数加法运算；成员函数重载运算符

#include 
using namespace std;
class complex{
public:
    complex();
    complex(double real, double imag);
public:
    //声明运算符重载
    complex operator+(const complex &A) const;
    void display() const;
private:
    double m_real;  //实部
    double m_imag;  //虚部
};
complex::complex(): m_real(0.0), m_imag(0.0){ }
complex::complex(double real, double imag): m_real(real), m_imag(imag){ }
//实现运算符重载
complex complex::operator+(const complex &A) const{
    return complex(this->m_real + A.m_real, this->m_imag + A.m_imag);//返回临时对象
}
void complex::display() const{
    cout<

可以看出：运算符重载是通过函数实现的，它本质上是函数重载。

运算符重载格式：

返回值类型 operator 运算符名称 (形参表列){
//TODO:
}

operator是关键字，专门用于定义重载运算符的函数。我们可以将`operator 运算符名称`这一部分看做函数名，对于上面的代码，函数名就是operator+

即是：运算符重载除了函数名不同，其他地方和函数没有什么区别；

当执行c3 = c1 + c2;语句时，编译器检测到+号左边（+号具有左结合性，所以先检测左边）是一个 complex 对象，就会调用成员函数operator+()，也就是转换为下面的形式：

c3 = c1.operator+(c2);

c1 是要调用函数的对象，c2 是函数的实参。

全局内重载运算符：

运算符重载函数不仅可以作为类的成员函数，还可以作为全局函数。利用友元函数来实现（获取private属性，归属于全局函数的应用）

更改上述例子：

#include 
using namespace std;
class complex{
public:
    complex();
    complex(double real, double imag);
public:
    void display() const;
    //声明为友元函数
    friend complex operator+(const complex &A, const complex &B);
private:
    double m_real;
    double m_imag;
};
complex operator+(const complex &A, const complex &B);
complex::complex(): m_real(0.0), m_imag(0.0){ }
complex::complex(double real, double imag): m_real(real), m_imag(imag){ }
void complex::display() const{
    cout<

通过运算符重载，扩大了C++已有运算符的功能，使之能用于对象,更人性了hhh；

tip: 非静态成员函数后面加const（加到非成员函数或静态成员后面会产生编译错误,静态和非静态的区别就是,查看下面链接），表示成员函数隐含传入的this指针为const指针，决定了在该成员函数中，任意修改它所在的类的成员的操作都是不允许的（因为隐含了对this指针的const引用）；唯一的例外是对于mutable修饰的成员。加了const的成员函数可以被非const对象和const对象调用，但不加const的成员函数只能被非const对象调用。静态函数和非静态函数的区别、什么是mutable

运算符重载的规则

  • 可以重载的运算符：+ - * / % ^ & | ~ ! = < > += -= = /= %= ^= &= |= << >> <<= >>= == != <= >= && || ++ -- , -> -> () [] new new[] delete delete[] ，自增自减运算符的前置和后置形式都可以重载

长度运算符sizeof、条件运算符: ?、成员选择符.和域解析运算符::不能被重载。

  • 重载不能改变运算符的优先级和结合性，如+-*/等运算符的优先级不会被改变；
  • 运算符重载函数不能有默认的参数，否则就改变了运算符操作数的个数（比如+号默认参数为1，结果肯定不对），这显然是错误的（有的博客说重载函数要有遵循固定数量的参数，和公认的相同）
  • 运算符重载函数既可以作为类的成员函数，也可以作为全局函数

将运算符重载函数作为类的成员函数时，二元运算符的参数只有一个，一元运算符不需要参数。之所以少一个参数，是因为这个参数是隐含的，是这个类对象本身；如上面的this，通过 this 指针隐式的访问 c1 的成员变量。

将运算符重载函数作为全局函数时，二元操作符就需要两个参数，一元操作符需要一个参数，而且其中必须至少有一个参数是对象，好让编译器区分这是程序员自定义的运算符，防止程序员修改用于内置类型的运算符的性质，比如：

int operator + (int a,int b){//显然错误，会造成歧义，改变内置类型的运算符的性质（别人设过的东西你别用）
    return (a-b);
}

而如果上述的a或者b是一个对象，那么就是成立的；

同时，将运算符重载函数作为全局函数时，一般都需要在类中将该函数声明为友元函数。原因很简单，该函数大部分情况下都需要使用类的 private 成员。

  • 箭头运算符->、下标运算符[ ]、函数调用运算符( )、赋值运算符=只能以成员函数的形式重载。

重载数学运算符例子

实际开发中重载数学运算符号非常常见，比如c++只是定义了复数的==，我们来实现复数的+，-，*，例子如下：

#include 
#include 
using namespace std;
//复数类
class Complex{
public:  //构造函数
    Complex(double real = 0.0, double imag = 0.0): m_real(real), m_imag(imag){ }
public:  //运算符重载
    //以全局函数的形式重载！！！！！！！！！！！
    friend Complex operator+(const Complex &c1, const Complex &c2);
    friend Complex operator-(const Complex &c1, const Complex &c2);
    friend Complex operator*(const Complex &c1, const Complex &c2);
    friend Complex operator/(const Complex &c1, const Complex &c2);
    friend bool operator==(const Complex &c1, const Complex &c2);
    friend bool operator!=(const Complex &c1, const Complex &c2);
    //以成员函数的形式重载！！！！！！！！！！！！
    Complex & operator+=(const Complex &c);
    Complex & operator-=(const Complex &c);
    Complex & operator*=(const Complex &c);
    Complex & operator/=(const Complex &c);
public:  //成员函数
    double real() const{ return m_real; }
    double imag() const{ return m_imag; }
private:
    double m_real;  //实部
    double m_imag;  //虚部
};
//重载+运算符
Complex operator+(const Complex &c1, const Complex &c2){
    return 
    Complex c;
    c.m_real = c1.m_real + c2.m_real;
    c.m_imag = c1.m_imag + c2.m_imag;
    return c;
}
//重载-运算符
Complex operator-(const Complex &c1, const Complex &c2){
    Complex c;
    c.m_real = c1.m_real - c2.m_real;
    c.m_imag = c1.m_imag - c2.m_imag;
    return c;
}
//重载*运算符  (a+bi) * (c+di) = (ac-bd) + (bc+ad)i
Complex operator*(const Complex &c1, const Complex &c2){
    Complex c;
    c.m_real = c1.m_real * c2.m_real - c1.m_imag * c2.m_imag;
    c.m_imag = c1.m_imag * c2.m_real + c1.m_real * c2.m_imag;
    return c;
}
//重载/运算符  (a+bi) / (c+di) = [(ac+bd) / (c²+d²)] + [(bc-ad) / (c²+d²)]i
Complex operator/(const Complex &c1, const Complex &c2){
    Complex c;
    c.m_real = (c1.m_real*c2.m_real + c1.m_imag*c2.m_imag) / (pow(c2.m_real, 2) + pow(c2.m_imag, 2));
    c.m_imag = (c1.m_imag*c2.m_real - c1.m_real*c2.m_imag) / (pow(c2.m_real, 2) + pow(c2.m_imag, 2));
    return c;
}
//重载==运算符
bool operator==(const Complex &c1, const Complex &c2){
    if( c1.m_real == c2.m_real && c1.m_imag == c2.m_imag ){
        return true;
    }else{
        return false;
    }
}
//重载!=运算符
bool operator!=(const Complex &c1, const Complex &c2){
    if( c1.m_real != c2.m_real || c1.m_imag != c2.m_imag ){
        return true;
    }else{
        return false;
    }
}
//重载+=运算符，开始有&符号
Complex & Complex::operator+=(const Complex &c){
    this->m_real += c.m_real;
    this->m_imag += c.m_imag;
    return *this;//this就是一个指针，*解引用，返回的是this指向的对象
}
//重载-=运算符
Complex & Complex::operator-=(const Complex &c){
    this->m_real -= c.m_real;
    this->m_imag -= c.m_imag;
    return *this;
}
//重载*=运算符
Complex & Complex::operator*=(const Complex &c){
    this->m_real = this->m_real * c.m_real - this->m_imag * c.m_imag;
    this->m_imag = this->m_imag * c.m_real + this->m_real * c.m_imag;
    return *this;
}
//重载/=运算符
Complex & Complex::operator/=(const Complex &c){
    this->m_real = (this->m_real*c.m_real + this->m_imag*c.m_imag) / (pow(c.m_real, 2) + pow(c.m_imag, 2));
    this->m_imag = (this->m_imag*c.m_real - this->m_real*c.m_imag) / (pow(c.m_real, 2) + pow(c.m_imag, 2));
    return *this;
}
int main(){
    Complex c1(25, 35);
    Complex c2(10, 20);
    Complex c3(1, 2);
    Complex c4(4, 9);
    Complex c5(34, 6);
    Complex c6(80, 90);
   
    Complex c7 = c1 + c2;
    Complex c8 = c1 - c2;
    Complex c9 = c1 * c2;
    Complex c10 = c1 / c2;
    cout<<"c7 = "<

运行结果：

选择是成员函数还是全局函数运算符重载

看例子：

Complex(double real): m_real(real), m_imag(0.0){ }  //转换构造函数
//重载+号运算符，设置成全局函数运算符重载
Complex operator+(const Complex &c1, const Complex &c2)
.....
Complex c2 = c1 + 15.6;//正确
Complex c3 = 28.23 + c1;//正确

为什么要设置成全局运算符呢？

因为如果设置成成员函数，Complex c3 = 28.23 + c1;将会是错误的；

原理：因为是全局函数，保证了 + 运算符的操作数能够被对称的处理，存在转换构造函数，编译器在检测到 Complex 和 double（小数默认为 double 类型）相加时，会先尝试将 double 转换为 Complex，或者反过来将 Complex 转换为 double（只有类型相同的数据才能进行 + 运算），如果都转换失败，或者都转换成功（产生了二义性），才报错。本例中，编译器会先通过构造函数Complex(double real);将 double 转换为 Complex，再调用重载过的 + 进行计算，整个过程类似于下面的形式：

设置成成员函数：根据“+ 运算符具有左结合性”这条原则，Complex c3 = 28.23 + c1会被转换为Complex c3 = (28.23).operator+(c1)，很显然这是错误的，因为 double 类型并没有以成员函数的形式重载 +。所以成员函数不能对此处理操作数；

为什么成员函数中不能用转换构造函数处理数据28.23为Complex(28.23)，而全局函数可以？

C++ 只会对成员函数的参数进行类型转换，而不会对调用成员函数的对象进行类型转换，因为设置为成员函数，28.23不是函数的参数，是拥有该函数的类对象，调用的将是28.23这个double对象的重载+，明显是没有的该函数，会报错；而全局函数，那么调用的将是operator+(28.23, c1)这个函数，那么28.23，c1都是函数的参数，是可以调用转换构造函数的。

注意ψ(｀∇´)ψ????：运算符重载的初衷是给类添加新的功能，方便类的运算，它作为类的成员函数是理所应当的，是首选的！

但是因为有处理对称的需求，每个类都重载一下运算符，过于麻烦了，所以允许采用全局函数重载。所以我们知道：参数具有逻辑的对称性，我们采用全局函数定义；第一个（最左的）运算对象不出现类型转换，我们运算符重载定义为成员函数；

C++ 规定，箭头运算符->、下标运算符[ ]、函数调用运算符( )、赋值运算符=只能以成员函数的形式重载。

重载<<和>>运算符

标准库本身已经对左移运算符<<和右移运算符>>分别进行了重载，使其能够用于不同数据的输入输出，但是输入输出的对象只能是 C++ 内置的数据类型（例如 bool、int、double 等）和标准库所包含的类类型（例如 string、complex、ofstream、ifstream 等）

有时候我们想重载输入输出符号，可以输入输出我们自己定义的类型，看下例，一样采用对复数的重载，基于上面的例子，加多实现输入输出：

//complex类中定义输入输出为友函数（只能定义为友函数），供全局可以使用，因为重载函数中用到了 complex 类的 private 成员变量，定义为成员函数依据左结合性，会非常奇怪，>>的左边需要一个complex类对象；
friend istream & operator>>(istream & in, complex & A);
friend ostream & operator<<(ostream & out, complex & A);

//重载输入运算符
istream & operator>>(istream & in, complex & A){
    in >> A.m_real >> A.m_imag;//输入，基于标准库的类；
    return in;//返回引用更方便再次使用，可以cin>>c1>>c2 ,连续输入两个对象；因为(cin>>c1)又是一个cin又可以cin>>c2;
}
//重载输出运算符
ostream & operator<<(ostream & out, complex & A){
    out << A.m_real <<" + "<< A.m_imag <<" i ";//输出，基于标准库的类
    return out;//与上同理
}
//main函数中：
complex c1, c2, c3;
cin>>c1>>c2;//具体逻辑：>>(cin, c1), >>(cin, c2)
c3 = c1 + c2;
cout<<"c1 + c2 = "<

输入函数定义为全局函数，相当于：operator>>(cin , c);

重载[]（下标运算符）

C++ 规定，下标运算符[ ]必须以成员函数的形式进行重载,重载函数在类中的声明如下：

返回值类型 & operator[ ] (参数);

或者：

const 返回值类型 & operator[ ] (参数) const;

使用第一种声明方式，[ ]不仅可以访问元素，还可以修改元素。使用第二种声明方式，[ ]只能访问而不能修改元素。在实际开发中，我们应该同时提供以上两种形式，这样做是为了适应 const 对象，因为通过 const 对象只能调用 const 成员函数，如果不提供第二种形式，那么将无法访问 const 对象的任何元素

例子：

#include 
using namespace std;
class Array{
public:
    Array(int length = 0);
    ~Array();
public:
    int & operator[](int i);
    const int & operator[](int i) const;
public:
    int length() const { return m_length; }
    void display() const;
private:
    int m_length;  //数组长度
    int *m_p;  //指向数组内存的指针
};
Array::Array(int length): m_length(length){
    if(length == 0){
        m_p = NULL;
    }else{
        m_p = new int[length];
    }
}
Array::~Array(){
    delete[] m_p;
}
int& Array::operator[](int i){
    return m_p[i];
}
const int & Array::operator[](int i) const{//注意两个const
    return m_p[i];
}
void Array::display() const{
    for(int i = 0; i < m_length; i++){
        if(i == m_length - 1){
            cout<>n;
    Array A(n);
    for(int i = 0, len = A.length(); i < len; i++){
        A[i] = i * 5;
    }
    A.display();
   
    const Array B(n);
    cout<

结果：

tip：const加在函数前后的区别

重载++和--

前置和后置++例子：

#include 
#include 
using namespace std;
//秒表类
class stopwatch{
public:
    stopwatch(): m_min(0), m_sec(0){ }
public:
    void setzero(){ m_min = 0; m_sec = 0; }
    stopwatch run();  // 运行
    stopwatch operator++();  //++i，前置形式
    stopwatch operator++(int);  //i++，后置形式，不写参数名形式
    friend ostream & operator<<( ostream &, const stopwatch &);
private:
    int m_min;  //分钟
    int m_sec;  //秒钟
};
stopwatch stopwatch::run(){
    ++m_sec;
    if(m_sec == 60){
        m_min++;
        m_sec = 0;
    }
    return *this;
}
stopwatch stopwatch::operator++(){
    return run();
}
stopwatch stopwatch::operator++(int n){
    stopwatch s = *this; // 拷贝构造
    run();
    return s; // 符合 用完再加的思想
}
ostream &operator<<( ostream & out, const stopwatch & s){
    out<

operator++ (int n) 函数实现自增的后置形式，返回值是对象本身，但是之后（过了这个表达式）再次使用该对象时，对象自增了，所以在该函数的函数体中，先将对象保存，然后调用一次 run() 函数，之后再将先前保存的对象返回（这个时候没有自增）。在这个函数中参数n是没有任何意义的，它的存在只是为了区分是前置形式还是后置形式。

结果：

重载new和delete

内存管理运算符 new、new[]、delete 和 delete[] 也可以进行重载，其重载形式既可以是类的成员函数，也可以是全局函数。一般情况下，内建的内存管理运算符就够用了，只有在需要自己管理内存时才会重载

new：

成员函数形式：

void * className::operator new( size_t size ){
    //TODO:
}

全局函数形式：

void * operator new( size_t size ){
    //TODO:
}

可以看出：两种重载形式的返回值相同，都是void *类型，并且都有一个参数，为size_t类型。在重载 new 或 new[] 时，无论是作为成员函数还是作为全局函数，它的第一个参数必须是 size_t 类型。size_t 表示的是要分配空间的大小，对于 new[] 的重载函数而言，size_t 则表示所需要分配的所有空间的总和。（size_t 在头文件 中被定义为typedef unsigned int size_t;，也就是无符号整型）

重载函数也可以有其他参数，但都必须有默认值，并且第一个参数的类型必须是 size_t。

delete：

成员函数：

void className::operator delete( void *ptr){
    //TODO:
}

全局函数：

void operator delete( void *ptr){
    //TODO:
}

两种重载形式的返回值都是 void 类型，并且都必须有一个 void 类型的指针作为参数，该指针指向需要释放的内存空间；

当我们以类成员重载了new和delete函数，使用例子：

C * c = new C;  //分配内存空间
//TODO:
delete c;  //释放内存空间

如果类中没有定义 new 和 delete 的重载函数，那么会自动调用内建的 new 和 delete 运算符；

例子:

#include
using namespace std;

class Foo
{
    public:
        int _id;
        long _data;
        string _str;
    public:
        Foo():_id(0){cout<<"default ctor.this="<

结果：

重载()

直接看例子：将 double类型强制转换运算符 进行重载

#include 
using namespace std;
class Complex
{
    double real, imag;
public:
    Complex(double r = 0, double i = 0) :real(r), imag(i) {};
    operator double() { return real; }  //重载强制类型转换运算符 double
};
int main()
{
    Complex c(1.2, 3.4);
    cout << (double)c << endl;  //输出 1.2
    double n = 2 + c;  //等价于 double n = 2 + c. operator double()
    cout << n;  //输出 3.2
}

类型强制转换运算符是单目运算符，也可以被重载，但只能重载为成员函数，不能重载为全局函数。经过适当重载后，(类型名)对象这个对 对象 进行强制类型转换的表达式就等价于对象.operator 类型名()，即变成对运算符函数的调用。

重载强制类型转换运算符时，不需要指定返回值类型，因为返回值类型是确定的，就是运算符本身代表的类型，在这里就是 double。

重载后的效果是，第 13 行的(double)c等价于c.operator double()。

有了对 double 运算符的重载，在本该出现 double 类型的变量或常量的地方，如果出现了一个 Complex 类型的对象，那么该对象的 operator double 成员函数就会被调用，然后取其返回值使用。

例如第 14 行，编译器认为本行中c这个位置如果出现的是 double 类型的数据，就能够解释得通，而 Complex 类正好重载了 double 运算符，因而本行就等价于：

double n = 2 + c.operator double();


网站栏目：初识C++05：运算符重载
本文网址：http://azwzsj.com/article/dsoijpc.html

其他资讯