c++运算符重及其调用

本文参考自：https://blog.csdn.net/lisemi/article/details/93618161

运算符重载就是赋予运算符新功能，其本质是一个函数。

运算符重载时要遵循以下规则:
1.除了类属关系运算符"."、成员指针运算符".*"、作用域运算符"::"、sizeof运算符和三目运算符"?:"以外，其他运算符都可以重载。
2.重载运算符限制在C++语言中已有的运算符范围内的允许重载的运算符之中，不能创建新的运算符
3.运算符重载实质上是函数重载，因此编译程序对运算符重载的选择，遵循函数重载的选择原则。
4.重载之后的运算符不能改变运算符的优先级和结合性，也不能改变运算符操作数的个数及语法结构。
5.运算符重载不能改变该运算符用于内部类型对象的含义。它只能和用户自定义类型的对象一起使用，或者用于用户自定义类型的对象和内部类型的对象混合使用时。
6.运算符重载是针对新类型数据的实际需要对原有运算符进行的适当的改造，重载的功能应当与原有功能相类似。
7.一个运算符被重载后，原有意思没有失去，只是定义了相对一特定类的一个新运算符。

#include<iostream>
using namespace std;

class Maritx{
public:
    Maritx(){
        cout<<"hello world"<<endl;
    }
    
    Maritx(Maritx & m,const int n[2][3],const int p[2][3],const int q[3][2]){
        for(int i=0;i<2;++i){
            for(int j=0;j<3;++j)m.a[i][j]=n[i][j];
        }
        for(int i=0;i<2;++i){
            for(int j=0;j<3;++j)m.a1[i][j]=p[i][j];    
        }
        for(int i=0;i<3;++i){
            for(int j=0;j<2;++j) m.a2[i][j]=q[i][j];
        }
    }

    void print(){
        for(int i=0;i<2;++i){
            for(int j=0;j<3;++j)cout<<a[i][j]<<" ";
        }
        cout<<endl;
        for(int i=0;i<2;++i){
            for(int j=0;j<3;++j)cout<<a1[i][j]<<" ";    
        }
        cout<<endl;
        for(int i=0;i<3;++i){
            for(int j=0;j<2;++j)cout<<a2[i][j]<<" ";
        }
        cout<<endl;
    }

    int & operator +(const Maritx & m){
        Maritx arr;
        for(int i=0;i<2;++i){
            for(int j=0;j<3;++j) {
                arr.a[i][j]=m.a[i][j]+m.a1[i][j];
                cout<<arr.a[i][j]<<" ";
            }
        }
        cout<<endl;
     }

     Maritx & operator -(const Maritx *m){
        Maritx arr;
        for(int i=0;i<2;++i){
            for(int j=0;j<3;++j) {
                arr.a[i][j]=(*m).a[i][j]-(*m).a1[i][j];
                cout<<arr.a[i][j]<<" ";
            }
        }
        cout<<endl;
     }

     Maritx & operator *(const Maritx &m){
        const int alength = sizeof(m.a)/sizeof(int); // 数组的大小
        const int acolumns = sizeof(m.a[0])/sizeof(int);  // 数组列
        const int arows = alength/acolumns;  // 数组行
        cout << "acolumns= "<<acolumns<<endl;
        cout << "arows= "<<arows<<endl;

        const int a2length = sizeof(m.a2)/sizeof(int); // 数组的大小
        const int a2columns = sizeof(m.a2[0])/sizeof(int);  // 数组列
        const int a2rows = a2length/a2columns;  // 数组行

        cout << "a2columns= "<<a2columns<<endl;
        cout << "a2rows= "<<a2rows<<endl;

        int newarr[a2rows][acolumns]={0};  // 存放两个矩阵相乘后得到的结果(3×3)
        int newarr1[arows][a2columns]={0};  // 存放两个矩阵相乘后得到的结果(2×2)
       
           cout<<"m.a2*m.a结果为: "<<endl;
        for(int i=0;i<acolumns;i++){
            for(int j=0;j<a2rows;j++){
                for(int k=0;k<a2columns;k++){
                    newarr[i][j]+=m.a2[i][k]*m.a[k][j];
                }         
                cout<<newarr[i][j]<<" ";
            }
            cout<<endl;
        }
        cout<<endl;

        cout<<"m.a*m.a2结果为: "<<endl;
        for(int i=0;i<a2columns;i++){
            for(int j=0;j<arows;j++){
                for(int k=0;k<acolumns;k++){
                    newarr1[i][j]+=m.a[i][k]*m.a2[k][j];
                }         
                cout<<newarr1[i][j]<<" ";
            }
            cout<<endl;
        }
        cout<<endl;
     }

     int operator[](const Maritx &m){  // 用成员方式重载运算符,不能改变参数的个数，二元运算符用成员重载时,只需要一个参数,另一个参数由this指针传入。如果需要两个参数，那么可以在类外面定义，然后在类里声明为友元。
         cout<<m.a[0][1]<<endl;
     }

    ~Maritx(){
        cout<<"释放内存"<<endl;
    };

    int a[2][3];
    int a1[2][3];
    int a2[3][2];    
};

int main(){
    Maritx m;
    int arr0[2][3]={{1,2,3},{4,5,6}};
    int arr1[2][3]={{1,2,3},{4,5,6}};
    int arr2[3][2]={{1,2},{3,4},{5,6}};
    Maritx(m,arr0,arr1,arr2);
    m.print();
    cout <<"运算符+"<<endl;
    m.operator+(m);
    cout <<"运算符-"<<endl;
    m.operator-(&m);
    cout <<"运算符*"<<endl;
    m.operator*(m);
    cout <<"运算符[]"<<endl;
    m.operator[](m);
    return 0;
}

原文地址：https://www.cnblogs.com/ligei/p/11451271.html