1

我的代码也可以在这里找到。

这段代码可以工作（但有很多代码重复）：

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);
}
4

3 回答 3

6

语言不允许您尝试进行的操作。但是，C++11 允许委托构造函数，因此您可以执行以下操作：

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

请注意，在另一个的初始化列表中调用了一个构造函数。

在 C++11 之前，一种选择是从所有构造函数中调用某种类型的初始化函数。但是，这在语义上是不同的，因为函数调用执行的是对成员变量的赋值，而不是初始化。

于 2012-08-30T20:55:32.963 回答
4

您不能将构造函数作为成员函数调用。您可以创建一个成员函数，并从构造函数和所有其他地方调用它。

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);
}
于 2012-08-30T20:53:51.130 回答
1

在 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.
于 2012-08-30T21:07:56.070 回答