在对象上重载 sum 运算符时，无法可靠地将两个 int 数组加在一起？

Can't reliably add two int arrays together when overloading sum operator on objects?

本文关键字：两个 加在一起 数组 int sum 重载 对象 运算符      更新时间：2023-10-16

我试图使用operator+函数将包含int数组的两个对象添加在一起。我得到的答案不可靠，我不知道为什么。为什么我的组合数组的一些成员得到奇怪的int值?

函数如下:

IntArray operator+(const IntArray& in1, const IntArray& in2){
    IntArray temp;
    for (int i = in1.low(); i <= in2.high(); i++){
        temp.iArray[i] = in1.iArray[i] + in2.iArray[i];
    }
    return temp;
}

，这里是我得到的输出:

Sum of two arrays assigned to third array: IntArray a(1, 5);
                                           IntArray b(4, 8);
                                           IntArray c = a + b;
a[1] = 10 a[2] = 20 a[3] = 30 a[4] = 40 a[5] = 50` 
b[4] = 40 b[5] = 50 b[6] = 60 b[7] = 70 b[8] = 80`
Press any key to continue.
c[0] = 0 c[1] = 32777 c[2] = 100 c[3] = 38 c[4] = 80 c[5] = 100 c[6] = 60 c[7] = 74 c[8] = 80 c[9] = 32767 
Press any key to continue.

我错过了什么吗?

编辑:添加IntArray的代码

class IntArray{
private:
    int *arrPtr;
    int iArray[SIZE];
    int arrLower, arrUpper;
    int size;
    string name;
public:
    IntArray();
    IntArray(int range);
    IntArray(int lower, int upper);
    IntArray(const IntArray& input);
    int high() const;
    int low() const;
    int compare(int in1, int in2) const;
    int operator==(const IntArray& in);  
    int operator!=(const IntArray& in);
    void setName(string input);
    IntArray& operator=(const IntArray& in);
    int& operator[] (int size)             {  return iArray[size];  }
    IntArray& operator+=( const IntArray& );
    friend IntArray operator+( const IntArray& in1, const IntArray& in2 );
    friend ostream& operator<<(ostream& os, const IntArray& i);

};

和构造函数:

IntArray::IntArray(int lower, int upper){
    arrLower = lower;
    arrUpper = upper;
    // Creates array size
    size = arrUpper - arrLower + 1;
    operator[](size);
}

这是整个程序的链接:

https://gist.github.com/anonymous/fd4b8a5e1d1ac4d0982a

虽然您没有展示IntArray的实现，但从结果来看，罪魁祸首似乎是for循环。我猜你的IntArray不会在low和high边界之外初始化值。但是，for循环假定索引为>= in1.low()的所有值对in2都有意义。但是，b[0]到b[3]将是未初始化的垃圾。这就是为什么c[0]到c[3]没有意义。一个简单的解决方案是更改operator[]的实现，以便在索引越界时返回一个适当的值(可能是0)。

编辑:看起来你想让operator[]成为non-const，使其更自然。因此，您可以简单地在operator+中适当地处理超出限制的情况。或者，提供一个const at函数，它进行范围检查，并在越界时返回一个假值。

没有什么奇怪的，如果你检查下面对齐的版本，你可以很容易地推断结果。

            a[1] = 10     a[2] = 20    a[3] = 30   **a[4] = 40 a[5] = 50** 
                                                   **b[4] = 40 b[5] = 50**  b[6] = 60 b[7] = 70 b[8] = 80
 c[0] = 0   c[1] = 32777  c[2] = 100   c[3] = 38   **c[4] = 80 c[5] = 100** c[6] = 60 c[7] = 74 c[8] = 80 c[9] = 32767

您的加法运算符将索引从in1.low()添加到in2.high()的数组元素，即在您的特定示例中，这将从1到8。但是，您永远不会在两个数组各自的范围之外初始化值。在每个数组中，超出范围的值包含垃圾。因此，在结果中的垃圾。

例如，in1.iArray[1]包含有意义的值。但是您从未初始化in2.iArray[1]。in2.iArray[1]包含垃圾。您在结果中看到的in1.iArray[1] + in2.iArray[1]计算为垃圾值是不足为奇的。

对于in2.iArray[2]和in2.iArray[3]也是如此。它们也含有垃圾。

代码中唯一有意义的添加是in1.iArray[4] + in1.iArray[4]和in1.iArray[5] + in1.iArray[5]。之后，它再次添加垃圾，这次在in1端:in1.iArray[6], in1.iArray[7]和in1.iArray[8]包含垃圾。

相关文章：