C++的操纵符重载概述

副标题#e#

1.什么是操纵符重载

可以利用分词将操纵符重载领略为：操纵符+重载。

C++中的操纵符许多，如+，-，*，\等等。

C++中的重载也是C++中面向工具多态的浮现。

简朴说操纵符重载：

C++中有：int a=2+3;　　那么a=5

操纵符重载可以实现对自界说范例的操纵：

#include <iostream>
using namespace std;
    
class Point{
public:
    int x;
    int y;
    Point(int _x,int _y):x(_x),y(_y){
    }
    
    Point operator+(Point &p){
        int t1=this->x+p.x;
        int t2=this->y+p.y;
        Point t(t1,t2);
        return t;
    }
};
    
int main()
{
    Point p1(1,3);
    Point p2(2,6);
    Point p3 = p1+p2;
    cout<<"p3:("<<p3.x<<","<<p3.y<<")";     ///执行输出：p3:(3,9)
    return 0;
}

2.操纵符重载的方法

操纵符重载的实现方法有两种，即通过“友元函数”可能“类成员函数”。如下面代码显示了这两种操纵符重载：

class Point{
public:
    int x;
    int y;
    Point(int _x,int _y);
    
    Point operator+(Point &p);  ///类成员函数，类成员函数可以利用this指针获取自身工具
    
    friend int operator*(Point &p1,Point &p2);  ///友元函数
};

可以看出，一个重载“+”，一个重载“*”，都是双目运算符，可是类成员函数只有一个参数。这是因为类成员函数可以利用this指针获取自身的工具，而友元函数则不可。

所以类成员实现操纵符重载需要的形式参数比本来少一个，这样利用类成员函数实现一元操纵符就不需要参数了。

3.操纵符重载例子

#include <iostream>
using namespace std;
    
class Point{
public:
    int x;
    int y;
    Point(int _x,int _y):x(_x),y(_y){
    }
    
    Point operator+(Point &p){  ///实现坐标向量加
        int t1=this->x+p.x;
        int t2=this->y+p.y;
        Point t(t1,t2);
        return t;
    }
    
    friend int operator*(Point &p1,Point &p2);  ///实现内积
};
    
int operator*(Point &p1,Point &p2)
{
    return (p1.x*p2.x)+(p1.y*p2.y);
}
    
int main()
{
    Point p1(1,3);
    Point p2(2,6);
    cout<<p1*p2<<endl;  ///输出内积：20
    
    Point p3 = p1+p2;
    cout<<"p3:("<<p3.x<<","<<p3.y<<")"<<endl;   ///输出坐标和：(3,9)
    return 0;
}

#p#副标题#e#

4.重载操纵符留意事项

(1)重载操纵符必需有一个类范例的参数。也就是说不能 int  operator+(int,int);

(2)操纵符的优先级和结核性是牢靠的。

(3)不在具有短路求值特性。如&&、||等，两个数城市举办求值，并且顺序不定。

(4)不要重载具有内置寄义的操纵符。重载操纵符主要是补充普通操纵符对类范例数据的浸染。像赋值操纵符、取地点操纵符、逗号操纵符等对类范例操纵数都有默认的寄义。

(5)只能对已有的C++运算符举办重载，不答允用户本身界说新的运算符。

(6)绝大部门的运算符可重载，除了成员会见运算符^.，浸染域运算符::，长度运算符sizeof以及条件运算符?:。

(7)运算符重载后不能改变运算符的操纵工具(操纵数)的个数。

5.特例操纵符"++"、"–"的重载

自增、自减操纵符有前后之分，通过一个无意义的整数参数来区分。无参数的是前置运算符，带参数的是后置运算符。

如：

int operator++();　　//前置

int operator++(int x);　　//后置

自增操纵符实例

#include <iostream>
using namespace std;
    
class Array{
public:
    Array(int _num){    ///初始化一个数组，巨细为_num
        this->a=new int[_num];
        this->num=_num;
        this->pos=0;
        for(int i=0;i<num;i=i+1)
            *((this->a)+i)=i;
    }
    
    ~Array(){
        delete [] a;
    }
    
    int operator++(){  ///++前置
        if(pos == num-1){
            cout<<"Fuck"<<endl;
            return 0;
        }
        return *((this->a)+(++pos));
    }
    
    int operator++(int x){   ///++后置
        if(pos == num-1){
            cout<<"Fuck"<<endl;
            return 0;
        }
        return *((this->a)+(pos++));
    }
    
    int *a;
    int pos;
    int num;
};
    
int main()
{
    Array array(100);
    cout<<"pos="<<array.pos<<endl;
    cout<<"pre_position:"<<(++array)<<endl;
    cout<<"pos="<<array.pos<<endl;
    cout<<"********************************************************"<<endl;
    
    cout<<"pos="<<array.pos<<endl;
    cout<<"post_position:"<<(array++)<<endl;
    cout<<"pos="<<array.pos<<endl;
    cout<<"********************************************************"<<endl;
    return 0;
}

执行功效：