运算符重载 +=

operator overloading +=

本文关键字：重载 运算符      更新时间：2023-10-16

我必须编写运算符重载+=但我不知道如何正确执行此操作(我开始编写它的代码末尾不正确，所以我删除了除您看到之外的所有内容(。

#include <iostream>
using namespace std;
class dek
{
private:
    int *x,na4,kon,n,razmer;
public:
    dek(int m)
    {
        x=new int[m];
        n=m;
        na4=1;
        kon=0;
        razmer=0;
    }
    ~dek()
    {
        delete [] x;
    }
    void v_n(int a)
    {
        if(razmer!=n)
        {
            na4--;
            if(na4<0)na4=n-1;
            x[na4]=a;
            razmer++;
        }
        else cout<<"dek polonn";
    }
    void v_k(int b)
    {
        if(razmer!=n)
        {
            kon++;
            if(kon>n-1)kon=0;
            x[kon]=b;
            razmer++;
        }
        else cout<<"dek polonn";
    }
    int size()
    {
        return razmer;
    }
    void u_n()
    {
        if(razmer!=0)
        {
            na4++;
            if(na4>n-1)na4=0;
            razmer--;
        }
        else cout<<"dek pustn";
    }
    void u_k()
    {
        if(razmer!=0)
        {
            kon--;
            if(kon<0)kon=n-1;
            razmer--;
        }
        else cout<<"dek pustn";
    }
    void pe4at()
    {
        int i=na4;
        if(razmer!=0)
        {
            while(1)
            {
                cout << x[i] << "  ";
                if(i==kon)break;
                i++;
                if(i>n-1)i=0;
            }
            cout << "n";
        }
    }
    dek& operator = (dek const& b)
    {
        if(&b!=this)
        {
            delete [] x;
            x=new int[b.n];
            n=b.n;
            razmer=b.razmer;
            na4=b.na4;
            kon=b.kon;
            if(razmer!=0)
            {
                int i=na4;
                while(1)
                {
                    x[i]=b.x[i];
                    if(i==kon)break;
                    i++;
                    if(i>n-1)i=0;
                }
            }
        }
        return *this;
    }
    dek const operator +(dek const& b)const
    {
        dek s(n+b.n);
        s.n=n+b.n;
        s.razmer=razmer+b.razmer;
        s.na4=0;
        s.kon=s.razmer-1;
        if(razmer!=0)
        {
            int j=0,i=na4;
            while(1)
            {
                s.x[j]=x[i];
                if(i==kon)break;
                i++;
                if(i>n-1)i=0;
                j++;
                if(j>s.n-1)j=0;
            }
        }
        if(b.razmer!=0)
        {
            int j=razmer,i=b.na4;
            while(1)
            {
                s.x[j]=b.x[i];
                if(i==b.kon)break;
                i++;
                if(i>b.n-1)i=0;
                j++;
                if(j>s.n-1)j=0;
            }
        }
        return s;
    }
    dek operator +=(dek const& b)
    {
    }
};

那么，a += b;的结果应该等同于 a = a + b; ;既然你已经定义了一个operator+，你就知道这些是什么语义是。 一旦通常的做法是首先定义operator+=，然后实现operator+(通常作为自由函数( += ：

MyClass
operator+( MyClass const& lhs, MyClass const& rhs )
{
    MyClass results( lhs );
    results += rhs;
    return results;
}

然后定义直接对类成员进行操作operator+=：

MyClass&
MyClass::operator+=( MyClass const& other )
{
    n += other.n;
    razmer += other.razmer;
    //  ...
    return *this;
}

(尽管有充分的理由使其成为非成员，传统上，operator+=是成员。 可能是因为operator=必须是会员。

此外，传统上，operator+=返回引用，因为这大多数类似于运算符在内置类型上的行为。

最后，关于一个完全不同的问题：你错过了一个副本构造函数(在您的情况下，如果您确实复制，这意味着双重删除(，并且您的operator=被破坏了(想想如果x = new int[b.n];失败并抛出std::bad_alloc会发生什么(。 古典解决方案是在副本中实现深度复制构造函数(使用或多或少与设置赋值运算符中的变量(和赋值运算符中的变量，以构建副本，然后交换元素。 这并不严格必要，但无论你做什么，你都必须做new(以及其他任何事情这可能会失败(，然后再更改要分配的对象中的值。(如果你这样做，自我分配的测试是没有用的;需要赋值测试通常是赋值运算符是坏了。

你需要实现void add(const dek &other) - 将其从"+"运算符中分离出来。

然后，您可以将 + 实现为 

dek new_dek(*this);
new_dek.add(other);
return new_dek;

您可以将+=实现为

this->add(other);
return *this;

(假设您将+=的返回类型更改为dek &(

相关文章：