c++ - 运算符重载+ =

我必须编写运算符重载+=，但是我不知道如何正确执行（我开始在代码末尾编写它，这是不正确的，所以我删除了所有内容，除非您看到）。

#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 polon\n";
    }

    void v_k(int b)
    {
        if(razmer!=n)
        {
            kon++;
            if(kon>n-1)kon=0;
            x[kon]=b;
            razmer++;
        }
        else cout<<"dek polon\n";
    }

    int size()
    {
        return razmer;
    }

    void u_n()
    {
        if(razmer!=0)
        {
            na4++;
            if(na4>n-1)na4=0;
            razmer--;
        }
        else cout<<"dek pust\n";
    }

    void u_k()
    {
        if(razmer!=0)
        {
            kon--;
            if(kon<0)kon=n-1;
            razmer--;
        }
        else cout<<"dek pust\n";
    }

    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（以及其他任何操作）
可能会失败），然后再更改要分配的对象中的值。
（如果这样做，自我分配的测试是没有用的；需要一个
分配测试通常是一个信号，表明分配运算符是
破碎。）

关于c++ - 运算符重载+ =，我们在Stack Overflow上找到一个类似的问题：https://stackoverflow.com/questions/9521463/