使用new(this)重用构造函数

Question

这是最近在我担任助教的班级中出现的。我们正在教学生如何在 c++ 中进行复制构造函数，而最初教 java 的学生问是否可以从一个构造函数调用另一个构造函数。我知道答案是否定的，因为他们在课堂上的代码中使用了迂腐的标志，而旧标准不支持这一点。我在 Stackoverflow 和其他网站上发现了一个建议，使用 new (this) 来伪造它，如下所示。

class MyClass
{
    private:
        int * storedValue;
    public:
        MyClass(int initialValue = 0)
        {
            storedValue = new int(initialValue);
        }

        ~ MyClass()
        {
            delete storedValue;
        }

        MyClass(const MyClass &b)
        {
            new (this) MyClass(*(b.storedValue));
        }

        int value() {
            return *storedValue;
        }
};

这是非常简单的代码，显然不会通过重用构造函数来保存任何代码，但它只是为了例子。

我的问题是，这是否符合标准，以及是否应该考虑任何边缘情况，从而阻止其成为健全的代码？

编辑：我应该指出，这对我来说似乎非常危险，但这更多是从我不真正了解它而不是知道它如何变坏的角度来看。我只是想确保如果学生问起这个问题，我可以指导他们为什么可以或不应该这样做。我已经建议他们出于所有实际目的使用共享初始化方法。这更多的是一个教学问题，而不是一个实际项目。

Answer 1

C++0x 将引入允许构造函数调用其他构造函数的语法。

在此之前，new(this) 在某些情况下有效，但并非全部。特别是，一旦进入构造函数，您的基类就已经完全构造完毕。通过 new(this) 进行重构会重新调用基类构造函数，而不调用基类析构函数，因此如果基类没有预料到这种黑客行为，那么就会出现问题——而且它们可能没有。

一个清晰的例子：

class Base
{
public:
   char *ptr;
   MyFile file;
   std::vector vect;
   Base()
   {
       ptr = new char[1000];
       file.open("some_file");
   }
   ~Base()
   {
       delete [] ptr;
       file.close();
   }
};

class Derived : Base
{
    Derived(Foo foo)
    {
    }
    Derived(Bar bar)
    {
       printf(ptr...);  // ptr in base is already valid
       new (this) Derived(bar.foo); // ptr re-allocated, original not deleted
       //Base.file opened twice, not closed
       // vect is who-knows-what
       // etc
    }
}

或者正如他们所说的“欢闹随之而来”

Answer 2

成员和基类将在进入构造函数主体之前初始化，然后在调用第二个构造函数时再次初始化。一般来说，这会导致内存泄漏和可能的未定义行为。

所以答案是“不，这不是健全的代码”。

Answer 3

以下是 C++ FAQ 在问题中对此的说法，“一个类的一个构造函数可以调用同一个类的另一个构造函数来初始化 this 对象吗？”：

顺便说一句，不要尝试通过放置新的方式来实现这一点。有些人认为他们可以在 Foo::Foo(char) 正文中说出 new(this) Foo(x, int(x)+7)。然而这很糟糕，很糟糕，很糟糕。请不要写信给我并告诉我它似乎可以在您的特定编译器的特定版本上运行；这很糟糕。构造函数在幕后做了很多神奇的小事情，但这种糟糕的技术会影响那些部分构造的部分。就说不吧。

Answer 4

除非您尝试调用父级的构造函数，否则我建议您创建一个私有初始化方法。没有理由不能在构造函数中调用共享初始值设定项。

Answer 5

如果您有这样的构造函数，则这不起作用：

class MyClass {
public:
    MyClass( const std::string & PathToFile )
    : m_File( PathToFile.c_str( ) )
    {
    }
private:
    std::ifstream m_File;
}

无法恢复原始参数，因此您无法从复制构造函数调用该构造函数。

Answer 6

当确切的代码被编写出来时，它应该可以工作——尽管我无法想象为什么你要编写这样的代码。特别是，它取决于以下事实：所有指针仅用于引用单个 int。既然如此，为什么他们不直接将 int 放入对象中，而是使用指针并动态分配 int 呢？简而言之，它们所拥有的内容很长且效率低下，但与以下内容没有显着不同：

class MyClass {
    int v;
public:
    MyClass(int init) : v(init) {}
    int value() { return v; }
};

不幸的是，当您尝试从指针中获得一些实际用途（例如，在不同对象中分配不同数量的内存）时，它们使用的“技巧” placement new 停止工作——这完全取决于每个对象分配完全相同的内存量的事实。由于每个分配都仅限于完全相同的分配，为什么要将该分配放入堆中而不是使其成为对象本身的一部分？

说实话，在某些情况下这样做是有意义的。然而，我立即想到的唯一一个问题是分配很大，并且您运行在堆空间比堆栈空间多得多的环境中。

该代码可以工作，但仅在相当狭窄的特定情况下才有用。我并不认为我会推荐它作为如何做事的例子。

Answer 7

在我看来，如果您知道自己在做什么，即使在派生类的构造函数中也可以安全地使用 new(this) 。您只需确保您的基类有一个虚拟构造函数（其基类也具有相同的构造函数，一直到链的下游）。例如：

#include <stdio.h>
#include <new>

struct Dummy {};

struct print
{
    print(const char *message)                    { fputs(message, stdout); }
    print(const char *format, int arg1)           { printf(format, arg1); }
    print(const char *format, int arg1, int arg2) { printf(format, arg1, arg2); }
};
struct print2 : public print
{
    print2(const char *message)                    : print(message) {}
    print2(const char *format, int arg1)           : print(format, arg1) {}
    print2(const char *format, int arg1, int arg2) : print(format, arg1, arg2) {}
};

class foo : public print
{
    int *n;
public:
    foo(Dummy) : print("foo::foo(Dummy) {}\n") {}
    foo() : print("foo::foo() : n(new int) {}\n"), n(new int) {}
    foo(int n) : print("foo::foo(int n=%d) : n(new int(n)) {}\n", n), n(new int(n)) {}
    int Get() const { return *n; }
    ~foo()
    {
        printf("foo::~foo() { delete n; }\n");
        delete n;
    }
};

class bar : public print2, public foo
{
public:
    bar(int x, int y) : print2("bar::bar(int x=%d, int y=%d) : foo(x*y) {}\n", x, y), foo(x*y) {}
    bar(int n) : print2("bar::bar(int n=%d) : foo(Dummy()) { new(this) bar(n, n); }\n", n), foo(Dummy())
    {
        __assume(this); // without this, MSVC++ compiles two extra instructions checking if this==NULL and skipping the constructor call if it does
        new(this) bar(n, n);
    }
    ~bar()
    {
        printf("bar::~bar() {}\n");
    }
};

void main()
{
    printf("bar z(4);\n");
    bar z(4);
    printf("z.Get() == %d\n", z.Get());
}

输出：

bar z(4);
bar::bar(int n=4) : foo(Dummy()) { new(this) bar(n, n); }
foo::foo(Dummy) {}
bar::bar(int x=4, int y=4) : foo(x*y) {}
foo::foo(int n=16) : n(new int(n)) {}
z.Get() == 16
bar::~bar() {}
foo::~foo() { delete n; }

如果基类具有常量*或引用成员（或者如果您无法编辑包含基类声明的文件），那么您当然不走运。这将使得在其中编写虚拟构造函数变得不可能 - 更不用说使用“new(this)”，然后您将初始化这些“常量”成员两次！这就是真正的东西，C++0x 委托构造函数，可以真正派上用场的地方。

请告诉我该技术是否还有其他不安全或不可移植的地方。

（编辑：我还意识到，也许在虚拟类中，虚拟函数表可能会被初始化两次。这将是无害的，但效率低下。我需要尝试一下，看看编译后的代码是什么样子。）

*如果你仅在基类中具有常量成员（并且没有引用），您并非完全不走运。您只需确保所有常量成员的所有类都有自己的虚拟构造函数，基类的虚拟构造函数可以依次调用它们。不过，如果某些常量具有像 int 这样的内置类型，那么你就不走运了——这些常量将不可避免地被初始化（例如，const int 将被初始化为零）。

编辑：这是一个链接虚拟构造函数的示例，如果 int value 在类 FooBar 内变为 const int value，该构造函数将会被破坏：

#include <stdio.h>
#include <new>

struct Dummy {};

struct print
{
    print(const char *message)                    { fputs(message, stdout); }
    print(const char *format, int arg1)           { printf(format, arg1); }
    print(const char *format, int arg1, int arg2) { printf(format, arg1, arg2); }
};
struct print2 : public print
{
    print2(const char *message)                    : print(message) {}
    print2(const char *format, int arg1)           : print(format, arg1) {}
    print2(const char *format, int arg1, int arg2) : print(format, arg1, arg2) {}
};

class FooBar : public print
{
    int value;
public:
    FooBar() : print("FooBar::FooBar() : value(0x12345678) {}\n"), value(0x12345678) {}
    FooBar(Dummy) : print("FooBar::FooBar(Dummy) {}\n") {}
    int Get() const { return value; }
};

class foo : public print
{
    const FooBar j;
    int *n;
public:
    foo(Dummy) : print("foo::foo(Dummy) : j(Dummy) {}\n"), j(Dummy()) {}
    foo() : print("foo::foo() : n(new int), j() {}\n"), n(new int), j() {}
    foo(int n) : print("foo::foo(int n=%d) : n(new int(n)), j() {}\n", n), n(new int(n)), j() {}
    int Get() const { return *n; }
    int GetJ() const { return j.Get(); }
    ~foo()
    {
        printf("foo::~foo() { delete n; }\n");
        delete n;
    }
};

class bar : public print2, public foo
{
public:
    bar(int x, int y) : print2("bar::bar(int x=%d, int y=%d) : foo(x*y) {}\n", x, y), foo(x*y) {}
    bar(int n) : print2("bar::bar(int n=%d) : foo(Dummy()) { new(this) bar(n, n); }\n", n), foo(Dummy())
    {
        printf("GetJ() == 0x%X\n", GetJ());
        __assume(this); // without this, MSVC++ compiles two extra instructions checking if this==NULL and skipping the constructor call if it does
        new(this) bar(n, n);
    }
    ~bar()
    {
        printf("bar::~bar() {}\n");
    }
};

void main()
{
    printf("bar z(4);\n");
    bar z(4);
    printf("z.Get() == %d\n", z.Get());
    printf("z.GetJ() == 0x%X\n", z.GetJ());
}

输出：

bar z(4);
bar::bar(int n=4) : foo(Dummy()) { new(this) bar(n, n); }
foo::foo(Dummy) : j(Dummy) {}
FooBar::FooBar(Dummy) {}
GetJ() == 0xCCCCCCCC
bar::bar(int x=4, int y=4) : foo(x*y) {}
foo::foo(int n=16) : n(new int(n)), j() {}
FooBar::FooBar() : value(0x12345678) {}
z.Get() == 16
z.GetJ() == 0x12345678
bar::~bar() {}
foo::~foo() { delete n; }

（0xCCCCCCCC 是未初始化的内存被初始化的内容在调试版本中。）