運算子過載的本質是一個函式

#include <iostream>
using namespace std;

class A {
private:
    int m_a;
    int m_b;

    friend A operator+(A &a1, A &a2);//友元函式訪問私有屬性，實現二元運算子過載

    friend A operator++(A &a); //友元函式訪問私有屬性，實現一元運算子過載（前置）

    /*後置為避免與前置函式定義相同，使用佔位符int，告訴編譯器是後置運算子過載*/
    friend A operator
 
++(A &a, int); //友元函式訪問私有屬性，實現一元運算子過載（後置）

    friend class B; //友元類，訪問私有屬性。若B類是A類的友員類，則B類的所有成員函式都是A類的友員函式

public: 
    A(int a){
        this->m_a = a;
    }

    A(int a, int b) {
        m_a = a;
        m_b = b;
    }

    void show() {
        cout << m_a << endl;
    }

};


class
 
 B {
private:
    A *pObjA = new A(21);

public:
    void showA() {
        cout << pObjA->m_a << endl;
    }

};

A operator+(A &a1, A &a2) {
    A tmp(a1.m_a + a2.m_a, a1.m_b + a2.m_b);
    return tmp;


}

A operator++(A &a) { //前置++
    a.m_a++;
    a.m_b++;
    return a;

}

A operator
 
++(A &a, int) {  //後置++
    A tmp = a;
    a.m_a++;
    a.m_b++;
    return tmp;
}

int main() {

    A a1(1, 9);
    A a2(3, 4);
    A a3 = a1 + a2;
    a3.show();

    ++a3;
    a3.show();

    a3++;
    a3.show();

    return 0;
}

class Complex
{
public:
    int a;
    int b;
    friend Complex operator+(Complex &c1, Complex &c2);
public:
    Complex(int a=0, int b=0)
    {
        this->a = a;
        this->b = b;
    }

public:
    void printCom()
    {
        cout<<a<<" + "<<b<<"i "<<endl;
    }

private:
};

/*
Complex myAdd(Complex &c1, Complex &c2)
{
    Complex tmp(c1.a+ c2.a, c1.b + c2.b);
    return tmp;
}
*/

Complex operator+(Complex &c1, Complex &c2)
{
    Complex tmp(c1.a+ c2.a, c1.b + c2.b);
    return tmp;
}

void main()
{
    Complex c1(1, 2), c2(3, 4);

    //Complex c3 = c1 + c2;  //使用者自定義型別 編譯器無法讓變數相加
    //Complex myAdd(Complex &c1, Complex &c2);

    //1 普通函式
    //Complex c3 = myAdd(c1, c2);
    //c3.printCom();

    //2 operator+ 函式名稱
    //Complex c3 = operator+(c1, c2);
    //c3.printCom();

    //3 +替換 函式名
    Complex c3 = c1 + c2; //思考C++編譯器如何支援操作符過載機制的 (根據型別)
    c3.printCom();
{
int a =0, b = 0, c; //基礎型別C++編譯器知道如何加減 
c = a +b;
}

    //4 把Complex類變成私有屬性
    //friend Complex operator+(Complex &c1, Complex &c2);

    cout<<"hello..."<<endl;
    system("pause");
    return ;
}

為vector類過載流插入運算子和提取運算子

class vector
{ 
public :
    vector( int size =1 ) ;       
    ~vector() ;
    int & operator[]( int i ) ;
    friend ostream & operator << ( ostream & output , vector & ) ;
    friend istream & operator >> ( istream & input, vector & ) ;
private :  
    int * v ;     
    int len ;
};

vector::vector( int size ) 
{ 
    if (size <= 0 || size > 100 )
    { 
        cout << "The size of " << size << " is null !\n" ; abort() ;  
    }
    v = new int[ size ] ;  len = size ;
}

vector :: ~vector() 
{ 
    delete[] v ;  
    len = 0 ; 
}

int &vector::operator[]( int i )        
{ 
    if( i >=0 && i < len )  return v[ i ] ;
    cout << "The subscript " << i << " is outside !\n" ;  abort() ;
}
ostream & operator << ( ostream & output, vector & ary )
{ 
    for(int i = 0 ; i < ary.len ; i ++ )  
        output << ary[ i ] << "  " ;
    output << endl ;
    return output ;
}
istream & operator >> ( istream & input, vector & ary ) 
{ 
    for( int i = 0 ; i < ary.len ; i ++ )  
        input >> ary[ i ] ;
    return  input ;
}

void main()
{ 
    int k ;
    cout << "Input the length of vector A :\n" ;     
    cin >> k ;
    vector A( k ) ;
    cout << "Input the elements of vector A :\n" ;     
    cin >> A ;
    cout << "Output the elements of vector A :\n" ;
    cout << A ;
    system("pause");
}