0

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

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

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

    return c;
}
4

5 回答 5

4

不。

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

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

真正意思：

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

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

你也不能声明一个以数组类型作为返回类型的函数；如果你尝试，它没有调整为指针类型，它只是非法的。

您可以定义接受某些容器类型 ( std::vector, std::array) 的参数的函数——无论如何这可能更有用。

一定要考虑operator+如果左右操作数的大小不同，你应该怎么做。（抛出异常是一种合理的方法。）

于 2013-05-29T22:56:49.763 回答
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
}

这是一个演示。

于 2013-05-29T23:10:20.337 回答
1

不，你不能。但是你可以用这种方式编写一个包装数组的类：

#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
于 2013-05-29T23:06:20.037 回答
1

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

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

但是有几个问题：

因此，要么将数组包装在用户定义的类型中，要么使用常规函数（如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];
}
于 2013-05-29T23:16:41.230 回答
0

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

于 2013-05-29T22:50:59.113 回答