在 C++ 中定义对象而不调用其构造函数；

Question

在 C++ 中，我想将一个对象定义为类的成员，如下所示：

Object myObject;

但是，这样做将尝试调用它的无参数构造函数，而该构造函数不存在。但是，我需要在包含的类完成一些初始化之后调用构造函数。像这样的东西。

class Program
{
public:
   Object myObject; //Should not try to call the constructor or do any initializing
   Program()
   {
      ...

      //Now call the constructor
      myObject = Object(...);
   }

}

Answer 1

存储指向对象而不是实际对象的指针

，因此：

class Program
{
public:
   Object* myObject; // Will not try to call the constructor or do any initializing
   Program()
   {
      //Do initialization
      myObject = new Object(...);  // Initialised now
   }

}

不要忘记在析构函数中删除它。现代 C++ 可以帮助您，因为您可以使用 auto_ptrshared_ptr 而不是原始内存指针。

Answer 2

其他人已经发布了使用原始指针的解决方案，但智能指针将是一个更好的主意：

class MyClass {
  std::unique_ptr<Object> pObj;
  // use boost::scoped_ptr for older compilers; std::unique_ptr is a C++0x feature
public:
  MyClass() {
    // ...
    pObj.reset(new Object(...));
    pObj->foo();
  }
  // Don't need a destructor
};

这避免了添加析构函数的需要，并且隐式禁止复制（除非您编写自己的 operator= 和 MyClass(const MyClass &)

如果您想避免单独的堆分配，可以使用 boost 的 aligned_storage 和放置 new 来完成：

template<typename T>
class DelayedAlloc : boost::noncopyable {
  boost::aligned_storage<sizeof(T)> storage;
  bool valid;
public:
  T &get() { assert(valid); return *(T *)storage.address(); }
  const T &get() const { assert(valid); return *(const T *)storage.address(); }

  DelayedAlloc() { valid = false; }

  // Note: Variadic templates require C++0x support
  template<typename Args...>
  void construct(Args&&... args)
  {
    assert(!valid);
    new(storage.address()) T(std::forward<Args>(args)...);
    valid = true;
  }

  void destruct() {
    assert(valid);
    valid = false;
    get().~T();
  }

  ~DelayedAlloc() { if (valid) destruct(); }
};

class MyClass {
  DelayedAlloc<Object> obj;
public:
  MyClass() {
    // ...
    obj.construct(...);
    obj.get().foo();
  }
}

或者，如果 。 Object 是可复制（或可移动）的，您可以使用 boost::optional：

class MyClass {
  boost::optional<Object> obj;
public:
  MyClass() {
    // ...
    obj = Object(...);
    obj->foo();
  }
};

Answer 3

您可以通过以下技巧完全控制对象的构造和销毁：

template<typename T>
struct DefferedObject
{
    DefferedObject(){}
    ~DefferedObject(){ value.~T(); }
    template<typename...TArgs>
    void Construct(TArgs&&...args)
    {
        new (&value) T(std::forward<TArgs>(args)...);
    }
public:
    union
    {
        T value;
    };
};

应用到您的示例：

class Program
{
public:
   DefferedObject<Object> myObject; //Should not try to call the constructor or do any initializing
   Program()
   {
      ...

      //Now call the constructor
      myObject.Construct(....);
   }

}

此解决方案的一大优点是，它不需要任何额外的分配，并且对象内存按正常方式分配，但您可以控制调用构造函数的时间。

另一个示例链接

Answer 4

如果您可以将其他初始化移至构造函数中，您还可以重写代码以使用构造函数初始值设定项列表：

class MyClass
  {
    MyObject myObject; // MyObject doesn't have a default constructor
  public:
    MyClass()
      : /* Make sure that any other initialization needed goes before myObject in other initializers*/
      , myObject(/*non-default parameters go here*/)
      {
      ...
      }
  };

您需要注意，遵循这样的模式将导致您走上一条需要做大量工作的道路在构造函数中，这反过来又导致需要掌握异常处理和安全性（因为从构造函数返回错误的规范方法是抛出异常）。

Answer 5

如果您有权访问 boost，则提供了一个名为 boost::Optional<> 的方便对象 - 这避免了动态分配的需要，例如

class foo
{
  foo()  // default std::string ctor is not called..
  {
    bar = boost::in_place<std::string>("foo"); // using in place construction (avoid temporary)
  }
private:
  boost::optional<std::string> bar;
};

Answer 6

涉及匿名联合和放置 new 的技巧

与 jenkas 的答案类似，但更直接

class Program
{
public:
   union{
   Object myObject;
   }; //being a union member in this case prevents the compiler from attempting to call the (undefined) default constructor
   
   Program()
   {
      ...

      //Now call the constructor
      new (&myObject) Object(...);
   }
   ~Program()
   {
      myobject.~Object(); //also make sure you explicitly call the object's destructor
   }

}

，但要注意的是，现在您必须显式定义所有特殊成员函数，因为编译器将默认删除它们。

Answer 7

您可以使用指针（或智能指针）来执行此操作。如果您不使用智能指针，请确保删除对象时您的代码释放内存。如果您使用智能指针，则不必担心。

class Program
{
public:
   Object * myObject;
   Program():
      myObject(new Object())
   {
   }
   ~Program()
   {
       delete myObject;
   }
   // WARNING: Create copy constructor and = operator to obey rule of three.
}

Answer 8

您可以通过使用 union

联合体的成员未初始化

来尝试创建联合体

template <typename T>
union uninitialized_value_of
{ T value; };

，然后每当您想要获取未初始化的值时。使用您想要的类型创建一个 uninitialized_value_of 对象，并获取对其成员 value 的

引用

class Program
{
    uninitialized_value_of<Object> MyObject;
    //Rest of your class
    //...
}