1

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

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

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

4

7 回答 7

11

让我们逐个检查您的代码，并查看问题：

int* operator+(const uint32& other) const{
  1. 你不能为内置类型重载运算符，所以这从一开始就注定了
  2. 即使你可以这样做（你不能），它也需要两个参数，因为它是非成员二进制函数。
    uint32 sum[n];
  1. 您不能在 C++ 中创建可变长度数组（假设n不是编译时常量）（注意：G++ 有一些扩展允许这样做，但它是非标准 C++）
    for(int i=0; i<n; i++){
        sum[i] = (*this[i]) + other[i];
  1. 这段代码中没有this开始的指针（它不是成员函数）......
  2. const uint32& other不是数组/指向数组的指针。它是对单个uint32. 这意味着other在这段代码中不是一个数组/指向数组的指针，所以你不能做other[i]（这就像试图做int x = 3; x[4] = 13;，这没有意义）。
    }
    return sum;
  1. 您正在返回一个指向本地分配数组的指针，这意味着这将导致未定义的行为，因为sum当此函数返回时，与之关联的内存将被销毁。
}
于 2013-02-25T05:14:22.877 回答
3

这可能是错误的，但它似乎工作（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
于 2013-02-25T05:58:33.377 回答
2

我认为问题在于您缺少一种传递数组长度的方法。您可能需要做一些更复杂的事情。就像是：

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;
     }
}
于 2013-02-25T05:09:22.140 回答
2

你不能这样做。非成员二元运算符必须采用两个参数（您只提供了一个），因此您可以尝试以下操作：

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. 所以你想要做的事情至少在两个不同的层面上已经是不可能的了。

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

于 2013-02-25T05:13:54.297 回答
1

首先是您的代码被正确编译，您在声明数组时直接使用了“n”，将“n”声明为常量。此外，您在函数中获取了一个局部变量并返回它，嗯，这会返回一个垃圾形式堆栈，我可以建议您分配一些内存并使用它，但是需要再次释放它...

嘿，你能做的是，

取一个包装类“数组”

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

然后在构造函数中你可以传递你想要的数组的大小

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

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

于 2013-02-25T05:14:06.727 回答
1

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

于 2013-02-25T05:14:27.763 回答
0

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

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

因此，如果您传入指向数组的指针以及数组的长度和输出数组，那么它将起作用，但您将没有语法

sum = a + b;

它会像

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

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

于 2013-02-25T05:20:20.163 回答