可以将此作业和复制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; 
}