可以將此作業和複製cnstr更好地組織

Question

我想改善我對複製構造函數和複製分配的理解。運營商 這裏是我想出了

class Bar 
{ 
    char* name; 
    int zip; 
    std::string address; 

    public: 
    Bar(const Bar& that) 
    { 
      //Copy constructor 
      size_t len = strlen(that.name + 1); 
      name = new char[len]; 
      strcpy(name, that.name); 

      //Copy the zip 
      this->zip = that.zip; 

      //Copy the address 
      this->address = that.address; 
    } 
    Bar& operator=(const Bar& that) 
    { 
     //Assignment operator 
     if(this != &that) 
     { 
      //Copy the name 
      size_t len = strlen(that.name + 1); 
      name = new char[len]; 
      strcpy(name, that.name); 

      //Copy the zip 
      this->zip = that.zip; 

      //Copy the address 
      this->address = that.address; 

     } 
     return *this; 
    } 
}; 

一個簡單的類我的問題是因爲在拷貝構造函數的代碼，拷貝賦值操作符是相同的它更有意義的統一是陷入了深深的複製方法，以便那incase我添加另一個成員變量我不必添加另一行到複製cnstr和複製分配。部分 ？有什麼建議麼 ？

Answer 1

做，你管理自己的資源的事物的「正常」的方式有一點不同：

char* cppstrdup(const char*s, int len=0); 
class Bar 
{ 
    char* name; 
    int zip; 
    std::string address;  
public: 
    Bar(const Bar& that) 
     :name(nullptr), 
     zip(that->zip), 
     address(that->address) 
    { 
     name = cppstrdup(that.name); //done here for exception safety reasons 
    } 
    Bar(Bar&& that) //if you have C++11 then you'll want this too 
     :name(nullptr) 
    { 
     swap(*this,that); 
    } 
    ~Bar() //you forgot the destructor 
    { 
     delete [] name; 
    } 
    Bar& operator=(Bar that) //this is called copy and swap. 
    { //"that" is a copy (notice, no & above), and we simply swap 
     swap(*this,that); 
     return *this; 
    } 
    friend void swap(Bar& left, Bar& right) 
    { 
     using std::swap; 
     swap(left.name, right.name); 
     swap(left.zip, right.zip); 
     swap(left.address, right.address); 
    } 
}; 
//uses new instead of malloc 
inline char* cppstrdup(const char* s, int len) 
{ 
    if (s==0) return nullptr; 
    if (len==0) len = strlen(s); 
    char* r = new char[len+1]; 
    strncpy(r, len+1, s); 
    r[len] = 0; 
    return r; 
} 

這種模式的好處是，獲得異常安全性要容易得多，通常具有強大的例外保證。

當然，更正常的是不使用char*這個名字，並且服從「零規則」是不變的。在這種情況下，它變得非常不同：

class Bar 
{ 
    std::string name; 
    int zip; 
    std::string address; 

public: 
    Bar() = default; //well, that's easy 
}; 

Answer 2

檢查COPY & SWAP成語。總之 - 你的邏輯進入拷貝構造函數和交換方法和你的賦值運算符是這樣的：

Bar& operator=(const Bar& that) 
{ 
    Bar temp(that); 
    swap(*this, temp); 
    return *this; 
}