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
}

这是demo。

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。
您无法从函数返回数组。参见例如Return array in a function。

因此要么将数组包装在用户定义的类型中，要么使用常规函数（如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 +

数组的重载运算符

5 个答案: