运算符重载编写有序数组类

下面是一个示例，演示如何运算符重载一个有序数组类：

#include <iostream>

class OrderedArray {
private:
    int* array;
    int size;
public:
    OrderedArray(int s) : size(s) {
        array = new int[size];
    }

    ~OrderedArray() {
        delete[] array;
    }

    // 运算符重载：输出有序数组
    friend std::ostream& operator<<(std::ostream& os, OrderedArray& obj) {
        for (int i = 0; i < obj.size; i++) {
            os << obj.array[i] << " ";
        }
        os << std::endl;
        return os;
    }

    // 运算符重载：比较两个有序数组是否相等
    bool operator==(const OrderedArray& rhs) const {
        if (size != rhs.size) {
            return false;
        }
        for (int i = 0; i < size; i++) {
            if (array[i] != rhs.array[i]) {
                return false;
            }
        }
        return true;
    }

    // 运算符重载：将两个有序数组合并成一个有序数组
    OrderedArray operator+(const OrderedArray& rhs) const {
        int newSize = size + rhs.size;
        int* newArray = new int[newSize];

        int i = 0, j = 0, k = 0;
        while (i < size && j < rhs.size) {
            if (array[i] <= rhs.array[j]) {
                newArray[k++] = array[i++];
            } else {
                newArray[k++] = rhs.array[j++];
            }
        }

        while (i < size) {
            newArray[k++] = array[i++];
        }

        while (j < rhs.size) {
            newArray[k++] = rhs.array[j++];
        }

        OrderedArray result(newSize);
        result.array = newArray;
        return result;
    }
};

int main() {
    OrderedArray arr1(5);
    arr1[0] = 3;
    arr1[1] = 5;
    arr1[2] = 7;
    arr1[3] = 9;
    arr1[4] = 11;

    OrderedArray arr2(5);
    arr2[0] = 2;
    arr2[1] = 4;
    arr2[2] = 6;
    arr2[3] = 8;
    arr2[4] = 10;

    OrderedArray arr3 = arr1 + arr2;
    std::cout << arr3;

    if (arr1 == arr2) {
        std::cout << "arr1 equals arr2" << std::endl;
    } else {
        std::cout << "arr1 does not equal arr2" << std::endl;
    }

    if (arr1 == arr1) {
        std::cout << "arr1 equals itself" << std::endl;
    } else {
        std::cout << "arr1 does not equal itself" << std::endl;
    }

    return 0;
}

在此示例中，我们定义了一个有序数组类`OrderedArray`，其中包含一个`array`指针，指向一个整数数组，以及一个`size`变量，表示数组的大小。我们定义了三个运算符重载：

- `operator<<`：输出有序数组。这个运算符使用`friend`关键字定义，以便可以访问`OrderedArray`类的私有成员。它遍历整个数组，并将每个元素输出到`std::ostream`对象中。
- `operator==`：比较两个有序数组是否相等。这个运算符采用常量引用作为参数，以避免对参数进行更改。它比较两个数组的大小和元素，并返回一个布尔值，表示它们是否相等。
- `operator+`：将两个有序数组合并成一个有序数组。这个运算符返回一个新的`OrderedArray`对象，它包含两个原始数组的所有元素，并按升序排序。

在`main()`函数中，我们创建了两个有序数组，并将它们相加，生成一个新的有序数组。我们还比较了两个有序数组是否相等。