c++ - 在c++中重载运算符+以添加两个数组

Question

这个问题在这里已经有了答案:





What are the basic rules and idioms for operator overloading?

(8 个回答)


1年前关闭。




任务是重载运算符 + 以便它添加两个数组。 Array 是一个具有两个私有(private)成员 int* data 和 int m(数组容量)的类。

void Array::setM(int m){
this->m = m;
this->data = new int[this->m];
}

int& Array::operator[](int i){
return this->data[i];
}


Array& Array::operator+(Array& a){
Array res;
if (this->m >= a.m) {
    res.setM(this->m);
    for (int i=0; i<this->m; i++){
    res.data[i] = this->data[i] + a.data[i];
    }
}
else if (this->m < a.m) {
    res.setM(a.m);
    for (int i=0; i<a.m; i++){
    res.data[i] = this->data[i] + a.data[i];
    }
}
Array& rez = res;
return rez;
}

这是主要的:

int main()
{
Array a(3);
Array& a1 = a;
a1[0] = 1;
a1[1] = 2;
a1[2] = 4;

Array b(3);
Array& b1 = b;
b1[0] = 1;
b1[1] = 2;
b1[2] = 4;

Array& c = a1.operator+(b1);
for (int i=0; i<3; i++){
    cout<<c[i]<<" ";
}
return 0;
}

该函数在返回类型为 Array 时工作正常，但当返回类型为 Array& 时，它返回 173104 4200736 4200896。我从 c++ 开始，所以引用让我有点困惑，我没有看到返回引用类型的函数点？

Answer 1

让我们逐步考虑您的运营商实现。
对于初学者来说，右手操作数不会在运算符中更改。所以函数应该至少声明为

Array& operator+( const Array& a );

该函数创建了一个 Array 类型的新对象。在它的体内。

Array res;

因此，由于对象是函数的局部变量，您可能不会返回对它的引用。这意味着应该将运算符声明为

Array operator+( const Array& a );

或者

const Array operator+( const Array& a );

此代码段

if (this->m >= a.m) {
    res.setM(this->m);
    for (int i=0; i<this->m; i++){
    res.data[i] = this->data[i] + a.data[i];
    }
}

a.m 时可以调用未定义的行为小于 this->m .
由于成员函数不会更改左操作数，因此该函数应该是一个常量成员函数。

const Array operator +( const Array& a ) const;

通常，此类运算符被声明为类的单独友元函数。

friend const Array operator+( const Array &a, const Array &b );

考虑到您在运算符中使用的算法，可以通过以下方式定义(在类定义之外。或者如果您想在类定义中定义它，那么您需要使用说明符 friend )

const Array operator+( const Array &a, const Array &b )
{
    int m = std::min( a.m, b.m );
    Array res( m );

    for ( int i = 0; i < m; i++ )
    {
        res.data[i] = a.data[i] + b.data[i];
    }

    return res;
}

注意函数setM可能会产生内存泄漏，因为它不会删除类型为 Array 的对象的早期分配内存

void Array::setM(int m){
this->m = m;
this->data = new int[this->m];
}

那就是函数不安全。
还要记住，带参数的构造函数应该用函数说明符 explicit 声明。 .否则，您可能会遇到整数到 Array 类型的意外转换。 .
当您动态分配数组时，您至少需要显式编写析构函数、复制构造函数和复制赋值运算符。