C++ 数组的重载运算符

是否可以重载加法运算符+以添加数组？比如：

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

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

    return c;
}

---

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

否

类型为array of T的参数在编译时被调整为指向T的类型指针，因此您的声明：

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

真正的意思是：

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

您不能为指针类型定义重载运算符+，至少gcc不这么认为，我相信这是正确的

也不能声明返回类型为数组类型的函数；如果您尝试，它不会调整为指针类型，这只是非法的

您可以定义使用某些容器类型std:：vector、std:：array的参数的函数，这可能更有用

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

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

#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;
}

---

不能重载采用非类类型操作数的全局运算符。幸运的是，我们可以使用std:：vector作为类类型：

#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
}

---

这里有一个。

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

// 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;
}

---

您正在处理原始数组。问题是您不知道数组的大小。和a[]+b[]；不起作用：我会让参数不需要左值。如果你使用的是C++11，你也可以提到std:：array。。似乎没有人喜欢/记得它？@DyP我本来会提到它，但我在实现它时遇到了困难。@DyP您正在添加数组的内容。我以为OP要求连接数组……而使用C++11您可以直接使用。@DyP:谢谢您这么说！我不知道。如果右操作数比左操作数短，运算符+将出现问题。并且在析构函数中，不应该删除arr；是否删除[]arr@基思：看我编辑的帖子。谢谢你的观察！注：我知道课程可能不完整。那只是为了演示，我想它真的需要一个拷贝。否则数组to_return=Arrayarr_size；将导致两个数组使用隐式定义的具有相同指针arr的copy-ctor。这两个数组在销毁时都将删除它->UB。看见

// 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;
}

// 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];
}