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

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 &)