c++运算符重载

对于单目运算符（以++运算符为例）：

前置单目运算符的重载函数没有形参：void operator++()

后置单目运算符的重载函数有形参：void operator++(int)

#include<iostream>  
using namespace std;  
  
class A{  
private:  
    int x,y;  
public:  
    A(int a,int b):x(a),y(b){}  
  
    // 前置单目运算符重载  
    A& operator++() // 返回对对象的引用  
    {  
        x+=1;  
        y+=1;  
        return *this; // 返回当前对象的引用  
    }   
  
    // 后置单目运算符重载  
    A operator++(int) // 哑元参数  
    {  
        A temp = *this; // 保存当前对象的状态  
        ++(*this);
		++(*this); // 调用前置版本增加对象的值  
        return temp; // 返回保存的对象状态  
    }  
  
    int getx()  
    {  
        return x;  
    }  
  
    int gety()  
    {  
        return y;  
    }  
};   
  
int main()  
{  
    int x = 1, y = 1;  
    A a(x,y);  
    cout<<a.getx()<<" "<<a.gety()<<endl;  
    a++; // 使用后置运算符  
    cout<<a.getx()<<" "<<a.gety()<<endl;  
    ++a; // 使用前置运算符  
    cout<<a.getx()<<" "<<a.gety()<<endl;  
}
/*结果
1 1
3 3
4 4*/

对于单目运算符（以+运算符为例）：

重载为类的成员函数(隐含this指针表示此对象)：以+为简单例子   a+b表示a+(b)   a+3表示a+(3)

#include<iostream>  
using namespace std;  
  
class A {  
private:  
    int x, y;  
public:  
    A(int a, int b) : x(a), y(b) {}  
  
    // 重载 + 操作符以接受一个整数并返回一个新的 A 对象  
    A operator+(int t) const {  
        return A(x + t, y + t);  
    }  
  
    // 重载 + 操作符以接受另一个 A 对象并返回一个新的 A 对象  
    A operator+(const A& b) const {  
        return A(x + b.x, y + b.y);  
    }  
  
    int getx() {  
        return x;  
    }  
  
    int gety() {  
        return y;  
    }  
};  
  
int main() {  
    int x = 1, y = 1;  
    A a(x, y);  
    cout << a.getx() << " " << a.gety() << endl;  
  
    // 使用新的 A 对象来存储结果  
    A result1 = a + 1;  
    cout << result1.getx() << " " << result1.gety() << endl;  
  
    // 使用新的 A 对象来存储结果  
    A result2 = a + a;  
    cout << result2.getx() << " " << result2.gety() << endl;  
}
/*结果
1 1
2 2
2 2*/

对于<<运算的重载：

#include<iostream>  
using namespace std;  
  
class A{  
private:  
    int x,y;  
public:  
    A(int a,int b):x(a),y(b){}  
  
    friend ostream& operator<<(ostream &out, const A &a)  
    {  
        out<<a.x<<" "<<a.y<<endl;  
        return out;  
    }  
};  
  
int main()  
{  
    int x = 1, y = 1;  
    A a(x,y);  
    cout<<a; // 现在正确地将 a 对象输出到 cout，输出为 "1 1\n"  
    return 0;  
}

对【】运算符的重载

一维数组

#include<iostream>  
using namespace std;  
  
class A{  
private:  
    int size;
	int *a;  
public:  
    A(int n):size(n){
	a = new int[size];
	}  
  
    int &operator[](int index)
    {
    	return a[index];
	}
	friend ostream& operator<<(ostream& out,A a)
	{
		for(int i=0;i<a.size;i++)
		out<<a.a[i]<<" ";
		return out;
	}
	~A()
	{
		delete []a;
	}
};   
  
int main()  
{  
    int n; 
	cin>>n; 
    A a(n);
	for(int i=0;i<n;i++)
	cin>>a[i]; 
	 
    cout<<a; 
}

二维数组

#include<iostream>    
using namespace std;    
  
class A {    
private:    
    int sizen, sizem;  
    int **a;    
public:    
    A(int n, int m) : sizen(n), sizem(m) {  
        a = new int*[sizen];  // 分配指针数组  
        for (int i = 0; i < sizen; i++) {  
            a[i] = new int[sizem];  // 为每个指针分配内存  
        }  
    }    
    
    int* operator[](int index) {  // 返回一个指向int*的指针  
        return a[index];  
    }  
    friend ostream& operator<<(ostream& out, const A& a);  // 使用const A& 避免复制  
  
    ~A() {  
        for (int i = 0; i < sizen; i++) {  
            delete[] a[i];  // 释放每个int数组  
        }  
        delete[] a;  // 释放指针数组  
    }  
};     
  
ostream& operator<<(ostream& out, const A& a) {  
    for (int i = 0; i < a.sizen; i++) {  
        for (int j = 0; j < a.sizem; j++) {  
            out << a.a[i][j] << " ";  // 访问a[i][j]  
        }  
        out << endl;  // 每行结束后换行  
    }  
    return out;  
}  
  
int main() {    
    int n, m;   
    cin >> n >> m;   
    A a(n, m);  
    for (int i = 0; i < n; i++) {  
        for (int j = 0; j < m; j++) {  
            cin >> a[i][j];   
        }  
    }  
    cout << a;   
    return 0;  
}