Question

使用关键字'new'有三种方法。首先是正常的方式。假设学生是一个班级。

Student *pStu=new Student("Name",age);

第二种方式。只需要在不调用构造函数的情况下询问内存空间。

Student *pArea=(Student*)operator new(sizeof(student));//

第三种方式称为“放置新”。只调用构造函数来初始化meomory空间。

new (pArea)Student("Name",age);

所以，我在下面写了一些代码。

class Student
{
private:
    std::string _name;
    int _age;
public:
    Student(std::string name, int age):_name(name), _age(age)
    {
        std::cout<<"in constructor!"<<std::endl;
    }
    ~Student()
    {
        std::cout<<"in destructor!"<<std::endl;
    }
    Student & assign(const Student &stu)
    {
        if(this!=&stu)
        {
            //here! Is it a good way to implement the assignment?
            this->~Student();

            new (this)Student(stu._name,stu._age);

        }
        return *this;
    }
};

此代码适用于gcc。但是我不确定它是否会导致错误，或者明确地调用析构函数是危险的。打电话给你一些建议？

Answer 1

“替换分配”的问题在于它不是例外安全。考虑这种简化的通用方法：

struct Foo
{
    Foo & operator=(Foo const & rhs)
    {
        if (this == &rhs) { return *this; }

        ~Foo();
        ::new (this) Foo(rhs);   // may throw!
    }

    // ...
};

现在，如果复制构造函数抛出异常，那么您就遇到了麻烦。您已经调用了自己的析构函数，因此不可避免的下一个析构函数调用将导致未定义的行为。你也无法改变周围的操作顺序，因为你没有任何其他记忆。

我实际上问过这种“踩地雷”的行为in a question of mine。

Answer 2

您的建议是一个主要的反模式：如果new终止除了一个例外，你将得到未定义的行为，如果有人试图从你的班级派生出各种奇怪的东西发生：

DerivedStudent a;
DerivedStudent b;
a = b;      //  Destructs a, and reconstructs it as a Student

当a超出范围时，它就是析构函数 DerivedStudent将被调用。

作为一般规则，如果你必须测试自我分配，你的赋值运算符不是异常安全的。

这个成语的目标当然是避免代码重复复制构造函数和赋值运算符之间，以及确保它们具有相同的语义。一般来说，最好的这样做的方法是使用交换习语或类似的东西：

Student&
Student::operator=( Student const& other )
{
    Student tmp( other );
    swap( tmp );
    return *this;
}

void
Student::swap( Student& other )
{
    myName.swap( other.myName );
    std::swap( myAge, other.myAge );
}

（最后一点，不相关的一点。在实践中，你会跑与以下划线开头的名称冲突。在一般来说，最好避免使用前导或尾随下划线。）

Answer 3

但我不确定它是否会导致错误，或者明确调用析构函数是危险的。打电话给你一些建议？

您编写的代码有三个主要缺点：

很难阅读
它针对不常见的情况进行了优化（总是执行自我分配检查，尽管您很少在实践中执行自我分配）
它不是例外安全

考虑使用复制和交换习语：

Student & assign(Student stu) // pass stu by value, constructing temp instance
{                             // this is the "copy" part of the idiom
    using namespace std;
    swap(*this, stu); // pass current values to temp instance to be destroyed
                      // and temp values to *this
    return *this;
} // temp goes out of scope thereby destroying previous value of *this

如果交换不抛出，这种方法是异常安全的，它有两个潜在的缺点：

如果Student是类层次结构的一部分（具有虚拟成员），则创建临时实例的成本会更高。
在自我赋值的情况下，实现应该是无操作（或自我平等测试），但在这种情况下，它将创建一个额外的对象实例。自我指派案件非常罕见。

一种通过'new'实现赋值的方法

3 个答案: