Перегрузка оператора +=

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

(Хотя есть веские причины для того, чтобы сделать его не членом, традиционно, operator+= является членом Наверное потому что operator=требуется быть членом.)

Также традиционно operator+= возвращает ссылку, потому что это больше всего напоминает поведение оператора для встроенных типов.

Наконец, совершенно другая проблема: вам не хватает конструктора копирования (что в вашем случае означает двойное удаление, если вы делаете копирование), и ваш operator= сломан (подумайте о том, что произойдет, если x = new int[b.n]; терпит неудачу и бросает std::bad_alloc). Классическим решением для этого было бы реализовать глубокое копирование в конструкторе копирования (используя более или менее ту же логику, которую вы используете при установке переменных в вашем операторе присваивания), и в операторе присваивания, чтобы создать копию, а затем поменять местами элементы, Это не обязательно, но что бы вы ни делали, вы должны сделать new (и все остальное, что может дать сбой) перед изменением значений в назначаемом объекте. (Если вы сделаете это, тест на самостоятельное назначение бесполезен; потребность в тесте на назначение обычно является сигналом о том, что оператор назначения нарушен.)

Answer 2

Вам нужно реализовать void add(const dek &other) - отделить его от оператора "+".

затем вы можете реализовать + как

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

И вы можете реализовать += как

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

(при условии, что вы измените тип возврата += в dek &)