Question

我想通过简单编写来添加两个数组：

int a[4] = {1,2,3,4};
int b[4] = {2,1,3,1};
int sum[4] = a + b;

我写了这个函数，但是我收到了一个错误

int* operator+(const uint32& other) const{
    uint32 sum[n];
    for(int i=0; i<n; i++){
        sum[i] = (*this[i]) + other[i];
    }
    return sum;
}

你能帮我解决这个问题吗？提前谢谢。

Answer 1

让我们逐个查看您的代码，然后查看问题：

int* operator+(const uint32& other) const{

您不能为内置类型重载运算符，因此这从一开始就注定失败
即使你可以这样做（你做不到），它也需要两个参数，因为它是非成员二元函数。

    uint32 sum[n];

你不能在C ++中创建可变长度数组（假设n不是编译时常量）（注意：G ++有一些允许这样做的扩展，但它是非标准的C ++）

    for(int i=0; i<n; i++){
        sum[i] = (*this[i]) + other[i];

此代码中没有this指针开头（它不是成员函数）...
const uint32& other 不是指向数组的数组/指针。它是对单个uint32的单一引用。这意味着此代码中的other 不指向数组的数组/指针，因此您无法执行other[i]（就像尝试int x = 3; x[4] = 13;一样，没有意义）。

    }
    return sum;

您将返回指向本地分配的数组的指针，这意味着这将导致未定义的行为，因为当此函数返回时，与sum关联的内存将被消灭。

Answer 2

这可能是错的，但似乎有效（C ++ 11）：

#include <iostream>
#include <array>

using namespace std;

template <class T>
T operator+(const T& a1, const T& a2)
{
  T a;
  for (typename T::size_type i = 0; i < a1.size(); i++)
    a[i] = a1[i] + a2[i];
  return a;
}

int main()
{
  array<int,5> a1 = { 1, 2, 3, 4, 5 };
  array<int,5> a2 = { 2, 3, 4, 5, 6 };
  array<int,5> a3 = a1 + a2;

  for (int i = 0; i < 5; i++)
    cout << a1[i] << '+' << a2[i] << '=' << a3[i] << ' ';

  cout << endl;
  return 0;
}

输出（ideone）：

1+2=3 2+3=5 3+4=7 4+5=9 5+6=11

Answer 3

我认为问题在于你错过了传递数组长度的方法。您可能需要做一些更复杂的事情。类似的东西：

class AddingVector : public std::vector<int>
{
    public:
    typedef AddingVector type;
    type operator+(const AddingVector& rhs, const AddingVector& lhs)
    {
       /* validate that they're the same size, decide how you want to handle that*/
       AddingVector retVal;
       AddingVector::const_iterator rIter = rhs.begin();
       AddingVector::const_iterator lIter = lhs.begin();
       while (rIter != rhs.end() && lIter != lhs.end()) {
         retVal.push_back(*rIter + *lIter);
         ++rIter;
         ++lIter;
       }
       return retVal;
     }
}

Answer 4

你做不到。非成员二元运算符必须带两个参数（你只提供一个），所以你可以试试这个：

int* operator+(const uint32& a, const uint32& b)

但这也不可行，因为你想要添加数组，而不是单个uint32变量。所以你会认为这会做到这一点：

int* operator+(const uint32[] a, const uint32[] b)

或：

int* operator+(const uint32[4] a, const uint32[4] b)

但是没有去。这是非法的，因为您不能将指针类型作为运算符重载中的两个参数。此外，至少有一个参数必须是类类型或enum。所以你要做的事情至少在两个不同的层面已经不可能了。

不可能做你想做的事。一个正确的方法是为一个可以添加到另一个数组的数组编写自己的类。

Answer 5

首先是你的代码被正确编译，你在声明数组时直接使用'n'，'n'声明为常量.. 而且你已经在函数中获取了一个局部变量并返回它，好吧，这会从堆栈中返回一个垃圾，我可以建议你使用malloc并使用它，但是需要再次释放它... < / p> 嘿，你能做的是，

采用包装类“array”

class array
{
   int *ipArr;
   DWORD size;
};

然后在构造函数中，您可以传递您想要的数组

array(DWORD dwSize);
{
  // then malloc memory of size dwSize;
}

对这个类有一个重载的运算符'+'，它将具有添加两个int数组的上述实现，注意这里你还需要覆盖'='赋值运算符，这样我们的数组类就可以直接... 现在你可以在析构函数中释放相关的内存

Answer 6

您不能为自己定义的类型以外的类型重载运算符。也就是说，如果你创建一个类X，你可以为X重载运算符，但你不能重载数组的运算符或基本类型的指针。

Answer 7

你有一些问题。第一个是你没有传入两个数组，然后你没有指定n是什么，最后一个是你试图传递指向局部变量的指针。看起来你正试图建立一个类的成员运算符。

所以基本上你试图将未指定长度数组的内容添加到相同长度的未初始化数组并返回堆栈内存。

因此，如果您将指针传递给数组以及数组的长度和输出数组，那么它就可以工作，但是您没有语法

sum = a + b;

就像是

addArray(&a, &b, &sum, 4);

要获得您想要的语法，您可以创建一个包装数组的类。但这是一项复杂得多的任务。

重载运算符'+'以在C ++中添加两个数组

7 个答案: