C++中加号重载运算符的具体使用

#include <iostream>
using namespace std;

// 复数类：实部 + 虚部i
class Complex {
private:
    double real; // 实部
    double imag; // 虚部
public:
    // 构造函数
    Complex(double r = 0.0, double i = 0.0) : real(r), imag(i) {}

    // 成员函数重载 + 运算符（左操作数是this，右操作数是c）
    Complex operator+(const Complex& c) const {
        // 不修改this和c，返回新的复数对象
        return Complex(real + c.real, imag + c.imag);
    }

    // 打印函数
    void print() const {
        cout << real << " + " << imag << "i" << endl;
    }
};

int main() {
    Complex c1(1.5, 2.5), c2(3.5, 4.5);
    Complex c3 = c1 + c2; // 等价于 c1.operator+(c2)
    c1.print(); // 1.5 + 2.5i（原对象未修改）
    c2.print(); // 3.5 + 4.5i（原对象未修改）
    c3.print(); // 5 + 7i（相加结果）
    return 0;
}

// 类内声明友元（如需访问私有成员）
friend 返回值类型 operator+(const 类名& 左操作数, const 类名& 右操作数);

// 全局定义
返回值类型 operator+(const 类名& 左操作数, const 类名& 右操作数) {
    // 实现相加逻辑
}

#include <iostream>
using namespace std;

class Complex {
private:
    double real;
    double imag;
public:
    Complex(double r = 0.0, double i = 0.0) : real(r), imag(i) {}

    // 声明友元：支持 Complex + Complex
    friend Complex operator+(const Complex& c1, const Complex& c2);
    // 声明友元：支持 int + Complex
    friend Complex operator+(int num, const Complex& c);
    // 声明友元：支持 Complex + int（可选，对称设计）
    friend Complex operator+(const Complex& c, int num);

    void print() const {
        cout << real << " + " << imag << "i" << endl;
    }
};

// 全局定义：Complex + Complex
Complex operator+(const Complex& c1, const Complex& c2) {
    return Complex(c1.real + c2.real, c1.imag + c2.imag);
}

// 全局定义：int + Complex
Complex operator+(int num, const Complex& c) {
    return Complex(num + c.real, c.imag);
}

// 全局定义：Complex + int
Complex operator+(const Complex& c, int num) {
    return Complex(c.real + num, c.imag);
}

int main() {
    Complex c1(1.5, 2.5);
    Complex c2 = 10 + c1; // int + Complex
    Complex c3 = c1 + 20; // Complex + int
    Complex c4 = c1 + c2; // Complex + Complex

    c2.print(); // 11.5 + 2.5i
    c3.print(); // 21.5 + 2.5i
    c4.print(); // 13 + 5i
    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) {}

    // 重载 +=（成员函数，修改自身）
    Complex& operator+=(const Complex& c) {
        real += c.real;
        imag += c.imag;
        return *this; // 返回自身，支持链式操作（如 c1 += c2 += c3）
    }

    // 基于 += 重载 +（成员函数）
    Complex operator+(const Complex& c) const {
        Complex temp = *this; // 拷贝当前对象
        temp += c; // 复用 += 逻辑
        return temp;
    }

    void print() const {
        cout << real << " + " << imag << "i" << endl;
    }
};

int main() {
    Complex c1(1, 2), c2(3, 4);
    c1 += c2; // c1 被修改：4 + 6i
    c1.print();

    Complex c3 = c1 + c2; // c3：7 + 10i
    c3.print();
    return 0;
}

#include <iostream>
#include <cstring>
using namespace std;

class MyString {
private:
    char* str;
    int len;
public:
    // 构造函数
    MyString(const char* s = "") {
        len = strlen(s);
        str = new char[len + 1];
        strcpy(str, s);
    }

    // 析构函数
    ~MyString() {
        delete[] str;
    }

    // 拷贝构造（避免浅拷贝）
    MyString(const MyString& other) {
        len = other.len;
        str = new char[len + 1];
        strcpy(str, other.str);
    }

    // 重载 +：字符串拼接
    friend MyString operator+(const MyString& s1, const MyString& s2) {
        MyString temp;
        temp.len = s1.len + s2.len;
        delete[] temp.str; // 释放默认构造的空字符串
        temp.str = new char[temp.len + 1];
        strcpy(temp.str, s1.str);
        strcat(temp.str, s2.str);
        return temp;
    }

    // 打印字符串
    void print() const {
        cout << str << endl;
    }
};

int main() {
    MyString s1("Hello"), s2(" World!");
    MyString s3 = s1 + s2;
    s3.print(); // Hello World!
    return 0;
}