返回值类型 operator 运算符 (形参表)
{
...
}

// 注意以下暂时将变量置于public以方便访问，正常情况下参见 friend 接口访问
// 此处的+重载为普通函数，但一般情况下还是更推荐重载为成员函数

#include <iostream>
using namespace std;
class Complex
{
public:
    double real, imag;
    Complex(double r = 0.0, double i = 0.0) : real(r), imag(i) {}
    Complex operator-(const Complex &c);
};
Complex operator+(const Complex &a, const Complex &b)
{
    return Complex(a.real + b.real, a.imag + b.imag);
}
Complex Complex::operator-(const Complex &c)
{
    return Complex(real - c.real, imag - c.imag);
}
int main()
{
    Complex a(4,4), b(1,1), c;
    c = a + b;
    cout << c.real << " , " << c.imag << endl;
    cout << (a-b).real << " , " << (a-b).imag << endl;
    return 0;
}

#include <iostream>
using namespace std;
class CArray{
private:
    int size; //数组元素个数
    int *ptr; //指向动态分配的数组
public:
    CArray(int s=0);
    CArray(const CArray &a);
    ~CArray();
    void push_back(int v); // 欲实现 a.push_back(...)
    
    // 更进一步的优化，应当是提供一个const版本
    CArray & operator=(const CArray &a); // 用于数组对象之间的赋值
    // 优化版本，const关键字防止修改
    int length () const {return size;} 
    
    //此处返回的是 int & 相当于是对下表的那块地址的引用
    int & operator[](int i){
        // 防越界
        assert(i>=0 && i<size); // 条件不成立程序直接终止并报错
        // 用于支持根据下标访问数组元素，如 a[i]=4 和 n=a[i]的语句
        return *(ptr+i); // 或者等价地写为 ptr[i]
    }
}; // ！
CArray::CArray(int s):size(s){
    if(s==0)
        ptr=NULL;
    else
        ptr=new int[s];
}
CArray::CArray(const CArray &a){
    if(!a.ptr){
        ptr=NULL;
        size=0;
        return;
    }
    ptr=new int[a.size];
    memcpy(ptr,a.ptr,sizeof(int)*a.size);
    size=a.size;
}
CArray::~CArray(){
    if(ptr) delete []ptr;
}
CArray & CArray::operator=(const CArray & a){
    //赋值号作用：“=”左边对象中存放的数组，大小和内容都和右边对象一样
    // 防自己，防空
    if(ptr==a.ptr) return *this; // 防止自等
    if(a.ptr==NULL){
        if(ptr) delete []ptr;
        ptr=NULL; // 清空地址后为悬浮指针，仍然指向原来地址，必须令为NULL保证安全
        size=0;
        return *this;
    }
    if(size<a.size){  // 只有不够才多申请，不用担心push，因为size也对已经改了
        if(ptr)
            delete []ptr;
        ptr=new int[a.size];
    }
    memcpy(ptr,a.ptr,sizeof(int)*a.size);
    size=a.size;
    return *this;
}
void CArray::push_back(int v){
    if(ptr){
        int *tmpPtr=new int[size+1]; // 重新分配空间
        memcpy(tmpPtr,ptr,sizeof(int)*size); // 复制原数组内容
        delete []ptr;
        ptr=tmpPtr;
    }
    else
        ptr=new int[1];
    	ptr[size++]=v; // 加入新的数组元素
}
int main(){
    CArray a;
    for(int i=0;i<5;++i)
        a.push_back(i);
    CArray a2,a3;
    a2=a;
    for(int i=0;i<a2.length();++i)
        cout<<a2[i]<<" ";
    cout<<endl;
    a[3]=100;
    CArray a4(a);
    for(int i=0;i<a4.length;++i)
        cout<<a4[i]<<" ";
    return 0;
}

#include <iostream>
#include <cstring>
using namespace std;
class String{
private:
    char *str;
public:
    String():str(NULL){}
    //定义转换构造函数（方便强制类型转换）
    String(const char* s):str(NULL){
        if(s){
            str=new char[strlen(s)+1];
            strcpy(str,s);
        }
    }
    //必须补充复制构造函数以使得String s=s2 生效,深拷贝！
    String(const String &s):str(NULL){
		if(s.str){
            str=new char[strlen(s.str)+1];
            strcpy(str,s.str);
        }
    }
    const char *c_str() const { return str;} // 加上前const防止对象内部被轻易修改，加上外const推广范围，使得const String 也可以调用
    String & operator=(const char*s);
    ~String(){ delete []str;} // 根据生成来确定，此外，C++ 标准规定 delete 或 delete[] 一个空指针是安全的（不会产生任何效果）无需检查
};
// 防自己，防空
// 浅拷贝（针对 const char*）
String & String::operator=(const char *s){
    if(str==s) return *this; // 少发生
    delete []str;
    if(s){
        str=new char[strlen(s)+1];
        strcpy(str,s);
	}
    else
        str=NULL;
    return *this;
}
// 深拷贝
String &String::operator=(const String &s){
    //if(str==s.str) return *this; // 可能出现误判！
    if(this==&s) return *this; // 直接判断是否为同一个对象，与成员具体的值无关，最可靠！
    delete []str;
    if(s.str){
        str=new char[strlen(s.str)+1];
		strcpy(str,s.str);
    }
    else
        str=NULL;
    return *this;
}
int main(){
    String s;
    s="Good Luck";
    cout<<s.c_str()<<endl;
    // String s2="hello!"; //在没有转换构造函数之前这句话是错的
    s="Shenzhou!";
    cout<<s.c_str()<<endl;
    return 0;
}

//实际上操作
class A{
public:
    int n;
};
ostream & operator<<(ostream & o,const A &a){
    o<<a.n;
    return o;
}
int main(){
    A a;
    a.n=5;
    cout<<a<<"hello";
    return 0;
}

class ostream{
	ostream & operator<<(int n){
		output(n);
		return *this;
	}
};

#include <iostream>
#include <string>
#include <cstdlib>
using namespace std;
class Complex{
private:
    double real,imag;
public:
    Complex(double r=0,double i=0):real(r),imag(i){}
    friend ostream & operator<<(ostream &os,const Complex &c);
    friend istream & operator>>(istream &is,Complex &c);
};
ostream & operator <<(ostream & os,const Complex & c)
{
    os<<c.real<<"+"<<c.imag<<"i";
    return os;
}
istream & operator >>(istream &is,Complex &c){
    string s;
    is>>s;
    int pos=s.find('+',0); // 默认“a+bi”不能有空格
    // 此处有个小小的坑：‘-’则不可处理
    
    // 分离实部和虚部
    string sTmp=s.substr(0,pos); 
    c.real=atof(sTmp.c_str()); // atof 将const char*指针指向内容转换为float
    sTmp=s.substr(pos+1,s.length()-pos-2);
    // 前面pos指的是实际位置-1=长度，取pos可；此处pos指的是+号的pos位置，+1即下一个位置，-2减掉加号和i号
    c.imag=atof(sTmp.c_str());
    return is;
    
    //实际上更推荐现成的 std::stod(sTmp)。它直接支持 std::string，且能处理转换失败的异常，不需要手动调用 .c_str()
}
int main(){
    Complex c;
    int n;
    cin>>c>>n;
    cout<<c<<","<<n;
    return 0;
}

#include <iostream>
using namespace std;
class Complex{
private:
    double real,imag;
public:
    Complex(double r=0,double i=0):real(r),imag(i){}
    // ☀️
    operator double(){ return real;} // 不需要指定返回类型！
};
int main(){
    Complex c(1.2,3.4);
    cout<<(double)c<<endl;
    double n=2+c; // 等价于 double n=2+c.operator()
    cout<<n;
    return 0;
}

#include <iostream>
using namespace std;
class CDemo{
private:
	int n;
public:
	CDemo(int i=0):n(i){}
	CDemo& operator++(); // 前置形式
	CDemo operator++(int); // 后置形式
	operator int(){ return n;}
	friend CDemo operator--(CDemo &);
	friend CDemo operator--(CDemo &,int);
};
// 此处 int 是约定不用接变量；其余则是类内声明只需类型，不一定接变量
// 采用CDemo&可以避免一次临时对象的拷贝，且支持 ++++a 这种连续操作
CDemo& CDemo::operator++(){ //返回自身引用
// 前置 ++
    n++;
    return *this;
}

// 注意以下需要先存放原来，操作后返回
CDemo CDemo::operator++(int k){ //返回一个临时变量
    // 后置++
    CDemo tmp(*this); //记录修改前的对象
    n++;
    return tmp;
}
CDemo operator--(CDemo & c){
    c.n--;
    return c;
}
CDemo operator--(CDemo & c,int k){
    CDemo tmp(c);
    c.n--;
    return tmp;
}
int main(){
    ...
}
// 此处--重载为全局函数为示范，重载为成员函数更佳