如何执行char *的深层副本？

Question

我对如何执行char *的深层复制有点困惑。这是我有：

Appointment(Appointment& a) 
{ 
    subject = new char; 
    *subject = *(a.subject); 
} 

Appointment(Appointment& b) 
{ 
    location = new char; 
    *location = *(b.location); 
} 

char *subject; 
char *location; 

我想执行一个深色副本的指针主题和位置。这会工作吗？如果没有，关于如何去做这件事的任何建议？

Answer 1

：

class Appointment 
{ 
public: 
    std::string subject; 
    std::string location; 

    Appointment() 
    { 
    } 

    Appointment(const Appointment& src) : 
     subject(src.subject), location(src.location) 
    { 
    } 

    Appointment& operator=(const Appointment& lhs) 
    { 
     subject = lhs.subject; 
     location = lhs.location; 
    } 
}; 

这可以进一步简化，由编译器生成的默认构造函数和赋值运算符足以自动为您深度的值复制C++，你应该使用std::string来满足你的字符串需求。

下面的代码，你写

Appointment(Appointment& a) 
{ 
    subject = new char; 
    *subject = *(a.subject); 
} 

不会做你认为它会做的，上面你分配一个字符（new char）则a.subject第一字符分配给它（*subject = *(a.subject)）

为了复制char*指向的字符串，您必须首先确定字符串长度，分配内存以保存字符串，然后复制字符。

Appointment(Appointment& a) 
{ 
    size_t len = strlen(a.subject)+1; 
    subject = new char [len]; // allocate for string and ending \0 
    strcpy_s(subject,len,a.subject); 
} 

到char*的另一种方法是使用一个std::vector<char>，这取决于你想用字符串做什么。

Answer 2

没有。

您需要分配足够的内存来存储您要复制

subject = new char [strlen(a.subject + 1]; // +1 to allow for null charcter terminating the string. 

然后用strncpymemcpy或复制所有的字符在循环中复制字符串

Answer 3

可以使用strdup的字符串。由于它在内部使用malloc，所以不要忘记在析构函数中调用free。

参见：

• strdup manual
• function - strdup() - what does it do in C? - Stack Overflow

Answer 4

你必须跟踪char*长度，以便使它们的副本，如：

class Appointment 
{ 
public: 
    char *subject; 
    int subject_len; 

    char *location; 
    int location_len; 

    Appointment() : 
     subject(NULL), subject_len(0), 
     location(NULL), location_len(0) 
    { 
    } 

    ~Appointment() 
    { 
     delete[] subject; 
     delete[] location; 
    } 

    Appointment(const Appointment& src) : 
     subject(new char[src.subject_len]), subject_len(src.subject_len), 
     location(new char[src.location_len]), location_len(src.location_len) 
    { 
     std::copy(src.subject, src.subject + src.subject_len, subject); 
     std::copy(src.location, src.location + src.location_len, location); 
    } 

    Appointment& operator=(const Appointment& lhs) 
    { 
     delete[] subject; 
     subject = NULL; 

     delete[] location; 
     location = NULL; 

     subject = new char[lhs.subject_len]; 
     subject_len = lhs.subject_len; 
     std::copy(lhs.subject, lhs.subject + lhs.subject_len, subject); 

     location = new char[lhs.location_len]; 
     location_len = lhs.location_len; 
     std::copy(lhs.location, lhs.location + lhs.location_len, location); 
    } 
}; 

在哪种情况下，你最好使用std::string相反：由于您使用的

class Appointment 
{ 
public: 
    std::string subject; 
    std::string location; 
};