Question

我正在尝试使用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

Answer 1

虽然您还没有提供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函数进行范围检查，如果超出界限则返回一个虚拟值。

Answer 2

您的加法运算符会添加从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]包含垃圾。

Answer 3

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

            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

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

3 个答案: