可重载和不可重载的运算符

C++中可重载的运算符如下：

而不可重载的运算符如下：

运算符重载的代码模板

 下面是代码中形参的统一解释：

lhs: 左操作数，通常为运算符左侧的对象或值。
rhs: 右操作数，通常为运算符右侧的对象或值。
val: 通常代表一个对象或值。
shift: 用于位运算的位移量，通常为一个整数值。
ptr: 通常代表一个指针对象。
member: 成员访问运算符的右操作数，它是一个类的成员指针。

index: 下标运算符的右操作数，它表示要访问的元素的索引。

还有一点，下面的代码大多数是将运算符重载函数写做普通的函数模板，并没有声明为类的成员函数。如果想要将对应的重载写成类的成员函数，那么只需要去掉函数中的第一个参数，一般来说第一个参数可以看作是被this指针代替了。（下面的标题是与上面的图片内容相对应的）

至于空间申请与释放运算符，由于太过复杂，所以就不写了。

双目算术运算符 (+, -, *, /, %)

// 加运算符重载
template <typename T>
T operator+(const T& lhs, const T& rhs) {
    return lhs + rhs;
}
// 减运算符重载
template <typename T>
T operator-(const T& lhs, const T& rhs) {
    return lhs - rhs;
}
// 乘运算符重载
template <typename T>
T operator*(const T& lhs, const T& rhs) {
    return lhs * rhs;
}
// 除运算符重载
template <typename T>
T operator/(const T& lhs, const T& rhs) {
    return lhs / rhs;
}
// 取模运算符重载
template <typename T>
T operator%(const T& lhs, const T& rhs) {
    return lhs % rhs;
}

关系运算符 (==, !=, <, >, <=, >=)

// 等于运算符重载
template <typename T>
bool operator==(const T& lhs, const T& rhs) {
    return lhs == rhs;
}
// 不等于运算符重载
template <typename T>
bool operator!=(const T& lhs, const T& rhs) {
    return lhs != rhs;
}
// 小于运算符重载
template <typename T>
bool operator<(const T& lhs, const T& rhs) {
    return lhs < rhs;
}
// 大于运算符重载
template <typename T>
bool operator>(const T& lhs, const T& rhs) {
    return lhs > rhs;
}
// 小于等于运算符重载
template <typename T>
bool operator<=(const T& lhs, const T& rhs) {
    return lhs <= rhs;
}
// 大于等于运算符重载
template <typename T>
bool operator>=(const T& lhs, const T& rhs) {
    return lhs >= rhs;
}

逻辑运算符 (!, &&, ||)

// 非运算符重载
template <typename T>
bool operator!(const T& val) {
    return !val;
}
// 与运算符重载
template <typename T>
bool operator&&(const T& lhs, const T& rhs) {
    return lhs && rhs;
}
// 或运算符重载
template <typename T>
bool operator||(const T& lhs, const T& rhs) {
    return lhs || rhs;
}

单目运算符（+，-，*，&）

// 正号运算符重载
template <typename T>
T operator+(const T& val) {
    return +val;
}
// 负号运算符重载
template <typename T>
T operator-(const T& val) {
    return -val;
}
// 指针运算符重载
template <typename T>
T& operator*(T* ptr) {
    return *ptr;
}

template <typename T>
const T& operator*(const T* ptr) {
    return *ptr;
}
// 取地址运算符重载
template <typename T>
const T* operator&(const T& val) {
    return &val;
}

template <typename T>
T* operator&(T& val) {
    return &val;
}

自增自减运算符（++，--）

// 自增运算符重载
template <typename T>
T& operator++(T& val) { //前置++
    ++val;
    return val;
}

template <typename T>
T operator++(T& val, int) { //后置++
    T old = val;
    ++val;
    return old;
}
// 自减运算符重载
template <typename T>
T& operator--(T& val) { //前置--
    --val;
    return val;
}

template <typename T>
T operator--(T& val, int) { //后置--
    T old = val;
    --val;
    return old;
}

位运算符 (&, |, ^, ~, <<, >>)

// 按位与重载
template <typename T>
T operator&(const T& lhs, const T& rhs) {
    return lhs & rhs;
}
// 按位或重载
template <typename T>
T operator|(const T& lhs, const T& rhs) {
    return lhs | rhs;
}
// 按位异或重载
template <typename T>
T operator^(const T& lhs, const T& rhs) {
    return lhs ^ rhs;
}
// 按位取反重载
template <typename T>
T operator~(const T& val) {
    return ~val;
}
// 左移运算符重载
template <typename T>
T operator<<(const T& val, int shift) {
    return val << shift;
}
// 右移运算符重载
template <typename T>
T operator>>(const T& val, int shift) {
    return val >> shift;
}

赋值运算符 (=, +=, -=, *=, /=, %=, &=, |=, ^=, <<=, >>=)

// =运算符重载
template <typename T>
T& operator=(T& lhs, const T& rhs) {
    lhs = rhs;
    return lhs;
}
// +=运算符重载
template <typename T>
T& operator+=(T& lhs, const T& rhs) {
    lhs += rhs;
    return lhs;
}
// -=运算符重载
template <typename T>
T& operator-=(T& lhs, const T& rhs) {
    lhs -= rhs;
    return lhs;
}
// *=运算符重载
template <typename T>
T& operator*=(T& lhs, const T& rhs) {
    lhs *= rhs;
    return lhs;
}
// /=运算符重载
template <typename T>
T& operator/=(T& lhs, const T& rhs) {
    lhs /= rhs;
    return lhs;
}
// %=运算符重载
template <typename T>
T& operator%=(T& lhs, const T& rhs) {
    lhs %= rhs;
    return lhs;
}
// &=运算符重载
template <typename T>
T& operator&=(T& lhs, const T& rhs) {
    lhs &= rhs;
    return lhs;
}
// |=运算符重载
template <typename T>
T& operator|=(T& lhs, const T& rhs) {
    lhs |= rhs;
    return lhs;
}
// ^=运算符重载
template <typename T>
T& operator^=(T& lhs, const T& rhs) {
    lhs ^= rhs;
    return lhs;
}
// <<=运算符重载
template <typename T>
T& operator<<=(T& val, int shift) {
    val <<= shift;
    return val;
}
// >>=运算符重载
template <typename T>
T& operator>>=(T& val, int shift) {
    val >>= shift;
    return val;
}

其它运算符（()，, ，[]）

// 函数调用运算符 重载
// 这里只是展示一种模板泛化版本
// 具体的实现要根据实际需求进行定义。
template <typename ReturnType, typename... Args>
ReturnType operator()(Args&&... args) {
    // 在这里实现函数调用的逻辑
    // 返回合适的类型对象
}

// 逗号运算符重载
template <typename T>
T operator,(const T& lhs, const T& rhs) {
    return (void(lhs), rhs); // 逗号运算符的返回值是右操作数的值
}
// 下标运算符重载
template <typename T, typename IndexType>
decltype(auto) operator[](T& val, const IndexType& index) {
    return val[index];
}
template <typename T, typename IndexType>
decltype(auto) operator[](const T& val, const IndexType& index) {
    return val[index];
}