c++ - 运算符重载 +=

Question

我必须写运算符重载 += 但我不知道如何正确地做它(我开始写它是代码的结尾它是不正确的所以我删除了除了你之外的所有内容见)。

#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)
    {

    }
};

Answer 1

嗯，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;
}

(虽然有很好的理由让它成为非成员(member)， 传统上，operator+= 是成员。可能是因为 operator= 必须成为成员(member)。)

此外，传统上，operator+= 返回一个引用，因为这 最类似于运算符对内置类型的行为。

最后，关于一个完全不同的问题:您丢失了一份拷贝 构造函数(在您的情况下，如果您复制，则意味着双重删除)， 并且你的 operator= 坏了(想想如果 x = new int[b.n]; 失败并抛出一个 std::bad_alloc)。经典的 解决方案是在拷贝中实现深层复制 构造函数(使用或多或少与设置 赋值运算符中的变量)，以及赋值运算符中的变量， 构造一个拷贝，然后交换元素。这不严格 必要的，但无论你做什么，你都必须做 new(以及其他任何事情 这可能会失败)在更改正在分配的对象中的值之前。 (如果你这样做， self 分配的测试是无用的；需要一个 赋值测试通常是赋值运算符是 坏了。)