数组的重载运算符

Question

是否可以重载加法运算符（+）来添加数组？ 就像是：

double operator+ (double a[], double b[])
{
    double c[];

    c[] = a[] + b[];

    return c;
}

Answer 1

没有。

在编译时将类型为“ T的数组”的参数调整为键入“指向T的指针”，因此您的声明为：

double operator+ (double a[], double b[])

真正意思：

double operator+ (double *a, double *b)

而且您不能为指针类型定义重载的operator+ （至少gcc认为不是，我相信这是正确的）。

您也不能声明以数组类型作为其返回类型的函数。 如果尝试，则不会将其调整为指针类型，这只是非法的。

您可以定义带有某些容器类型（ std::vector ， std::array ）的参数的函数-无论如何这可能更有用。

如果左右操作数的大小不同，请务必考虑您的operator+应该做什么。 （抛出异常是一种合理的方法。）

Answer 2

您不能重载采用非类类型的操作数的全局运算符。 幸运的是，我们可以使用std::vector<T> （ 属于类类型）：

#include <vector>
#include <algorithm>
#include <iostream>

template <typename T>
std::vector<T> operator +(std::vector<T> lhs, std::vector<T> rhs)
{
    std::vector<T> temp;
    temp.insert(temp.end(), lhs.begin(), lhs.end());
    temp.insert(temp.end(), rhs.begin(), rhs.end());

    return temp;
}

int main()
{
    std::vector<int> x{1, 2, 3}, y{4, 5, 6};

    std::vector<int> z(x + y);

    for (auto a : z)
        std::cout << a << ' '; // 1 2 3 4 5 6
}

这是一个演示 。

Answer 3

不，你不能。 但是您可以编写一个这样包装数组的类：

#include <iostream>
#include <algorithm>

class Array {
    int* arr;
    int arr_size;

    public:
        Array(int n): arr(new int[n]), arr_size(n) {}
        ~Array(){ delete[] arr; }
        int& operator[](int n) { return arr[n]; }
        Array operator+(Array& other) {
            Array to_return(arr_size);
            for(int i=0 ; i < std::min(arr_size, other.arr_size) ; i++)
                to_return[i] = arr[i] + other[i];
            return to_return;
        }
};

int main() {
    int tmp1[] = {1, 2, 3, 4};
    int tmp2[] = {5, 6, 7, 8};
    Array arr(4), arr2(4);
    for(int i=0 ; i < 4 ; i++) {
        arr[i] = tmp1[i];
        arr2[i] = tmp2[i];
    }
    for(int i=0 ; i < 4 ; i++)
        std::cout << (arr + arr2)[i] << ' ';

    return 0;
}

输出：

6 8 10 12

Answer 4

不直接。 原则上，您可以编写采用（引用）数组的函数：

// returns a[0]*b[0] + a[1]*b[1] + ... + a[N-1]*b[N-1]
template <int N>
double innerProduct(double const (& a)[N], double const (& b)[N])
{
    double sum = 0;
    for (size_t i = 0; i < N; ++i) sum += a[i] * b[i];
    return sum;
}

但是有几个问题：

• 您不能为内置类型重载operator+ （或任何其他运算符），只有在至少一个参数是用户定义的（数组不是这种情况）时，您才能这样做。 参见例如http://www.informit.com/guides/content.aspx?g=cplusplus&seqNum=256 。
• 您不能从函数返回数组。 参见例如函数中的返回数组 。

因此，要么将数组包装为用户定义的类型，要么使用常规函数（如addInto ）。 对于返回值，可以传递要填充的结果数组作为参数，或者返回其他某种类型，例如std::vector 。

例：

// c[0]=a[0]+b[0]; c[1]=a[1]+b[1]; ... c[N-1]=a[N-1]+b[N-1];
template <int N>
void addInto(double const (& a)[N], double const (& b)[N], double (& out)[N])
{
    for (size_t i = 0; i < N; ++i) out[i] = a[i] + b[i];
}

Answer 5

对于您编写的类，可以重载任何运算符。 请记住，运算符重载只是为了使代码更具可读性，如果您的运算符所做的事情不是很明显，则可能根本应该重载它。 另外，对于您正在考虑的这一特定对象，可能必须为数组编写自己的包装器类。 您不能直接重载它，因为已经为指针定义了operator + 。 您可能可以在C ++中为向量或数组数据类型重载operator +