C++中的運算符（operator）是一種特殊的函數，它允許我們在代碼中以簡潔的方式執行常見的操作。運算符重載是C++中的一個重要特性，它允許我們為自定義類型（如類或結構體）定義運算符的行為。

以下是一些常見的運算符及其用法：

1. 算術運算符：

class MyNumber {
public:
    int value;

    MyNumber(int v) : value(v) {}

    MyNumber operator+(const MyNumber& other) const {
        return MyNumber(value + other.value);
    }
};

int main() {
    MyNumber a(3);
    MyNumber b(4);
    MyNumber c = a + b; // 使用重載的運算符
    return 0;
}

2. 比較運算符：

class MyString {
public:
    std::string str;

    MyString(const std::string& s) : str(s) {}

    bool operator==(const MyString& other) const {
        return str == other.str;
    }
};

int main() {
    MyString s1("hello");
    MyString s2("world");
    MyString s3 = s1;

    if (s1 == s2) { // 使用重載的運算符
        std::cout << "s1 and s2 are equal" << std::endl;
    } else {
        std::cout << "s1 and s2 are not equal" << std::endl;
    }

    if (s1 == s3) { // 使用重載的運算符
        std::cout << "s1 and s3 are equal" << std::endl;
    } else {
        std::cout << "s1 and s3 are not equal" << std::endl;
    }

    return 0;
}

3. 賦值運算符：

class MyArray {
public:
    int* data;
    int size;

    MyArray(int* d, int s) : data(d), size(s) {}

    MyArray& operator=(const MyArray& other) {
        if (this != &other) {
            delete[] data;
            data = new int[other.size];
            size = other.size;
            std::copy(other.data, other.data + size, data);
        }
        return *this;
    }
};

int main() {
    int arr[] = {1, 2, 3, 4, 5};
    MyArray a(arr, 5);
    MyArray b = a; // 使用重載的運算符
    return 0;
}

4. 邏輯運算符：

class MyBool {
public:
    bool value;

    MyBool(bool v) : value(v) {}

    MyBool operator!(const MyBool& other) const {
        return MyBool(!other.value);
    }
};

int main() {
    MyBool a(true);
    MyBool b = !a; // 使用重載的運算符
    return 0;
}

這些示例展示了如何為自定義類型重載運算符，以便我們可以像使用內置類型一樣使用它們。請注意，當重載運算符時，我們需要遵循一些規則，例如保持運算符的語義一致，并確保重載的運算符具有合適的行為。