運算符重載+ =

我必須編寫運算符重載+=，但我不知道如何正確執行它（我開始寫它是代碼的結尾，它是不正確的，所以我刪除所有，除非你看到）。運算符重載+ =

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

    } 
};

來源

2012-03-01 Loki

你不確定怎麼辦？它看起來像你有一個開始，除了我相信+ =運營商必須返回一個參考 – 2012-03-01 18:04:26

我不知道什麼要寫在這裏dek operator + =（dek const＆b） – Loki 2012-03-01 18:07:27

@DanF沒有要求在關於'operator + ='返回類型的語言。然而好的做法需要它（正如它需要操作符具有與'operator +'的語義相關的語義一樣，並且這些語義與加法的概念有某種關係）。 – 2012-03-01 18:11:11

好了，結果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（以及其他任何可能失敗的）之前的更改正在分配的對象中的值。（如果你這樣做，自我分配測試是無用的; 測試的需要通常是一個信號，指派操作符是損壞。）

來源

2012-03-01 18:32:46

您需要實施void add(const dek &other) - 將其從「+」運算符中分離出來。

你就可以實現+作爲

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

而且可以實現+=作爲

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

（假設你改變+=返回類型dek &）

來源

2012-03-01 18:12:38 Arkadiy

運算符重載+ =

回答

相關問題