如何正確地從內部運算符構造函數調用複製構造函數？

Question

我的代碼也可以找到here。

此代碼將工作（但仍然有很多重複代碼）：

Employee::Employee(const Employee& x) 
{ 
     name=new char [strlen(x.name)+1]; 
     strcpy(name, x. name); 
     strcpy(EGN, x.EGN); 
     salary=x.salary; 
} 

void Employee::operator=(const Employee& x) 
{ 
     delete[] name; 
     name=new char [strlen(x.name)+1]; 
     strcpy(name, x. name); 
     strcpy(EGN, x.EGN); 
     salary=x.salary; 
} 

Employee::Employee(char* n, char* e, double s) 
{ 
     name = new char [strlen(n)+1]; 
     strcpy(name, n); 
     strcpy(EGN, e); 
     salary=s; 
} 

下面是我試圖避免編寫同樣的事情三次...但它不工作。難道不能縮短代碼嗎？

Employee::Employee(char* n, char* e, double s) 
{ 
     name = new char [strlen(n)+1]; 
     strcpy(name, n); 
     strcpy(EGN, e); 
     salary=s; 
} 

Employee::Employee(const Employee& x) 
{ 
     Employee(x.name, x.EGN, x.salary); 
} 

void Employee::operator=(const Employee& x) 
{ 
     delete[] name; 
     Employee(x); 
} 

Answer 1

您不能調用構造函數作爲成員函數。你可以創建一個成員函數，並從構造函數和所有其他地方調用它。

void Employee::Init(const char* n, const char* e, double s) 
{ 
     name = new char [strlen(n)+1]; 
     strcpy(name, n); 
     strcpy(EGN, e); 
     salary=s; 
} 

void Employee::Init(const Employee &x) 
{ 
     Init(x.name, x.EGN, x.salary); 
} 

Employee::Employee(char* n, char* e, double s) 
{ 
    Init(n,e,s); 
} 


Employee::Employee(const Employee& x) 
{ 
    Init(x); 
} 

void Employee::operator=(const Employee& x) 
{ 
     delete[] name; 
     Init(x); 
} 

Answer 2

你正在嘗試的是不被該語言允許的。然而，C++ 11允許delegating constructors，所以你可以做這樣的事情：

Employee::Employee(const Employee& x) : Employee(x.name, x.EGN, x.salary){} 

注意，一個構造函數在其他的初始化列表。

在C++ 11之前，一個選項可能會有一些從所有構造函數中調用的初始化函數。然而，這在語義上是不同的，因爲函數調用執行賦值給成員變量，而不是初始化。

Answer 3

嘗試在C++ 11

Employee::Employee(char* n, char* e, double s) 
{ 
     name = new char [strlen(n)+1]; 
     strcpy(name, n); 
     strcpy(EGN, e); 
     salary=s; 
} 

// Constructor chaining (delegation) like this. 
Employee::Employee(const Employee& x) 
    : Employee(x.name, x.EGN, x.salary) 
{} 


// Use copy and swap for the assignment operator: 

// Common convention to return a reference to yourself to allow chaingin. 
Employee& Employee::operator=(Employee x) // Pass by value to get the copy. 
{ 
    x.swap(*this);       // Then swap members 
    return *this; 
}           // Destructor will then cleanup.