动态分配数组时设置 Tor 参数

Question

我正在尝试动态分配对象数组。我的每一件物品 在他们的构造函数中有一个必须初始化的参数。我宁愿在施工时初始化它们，因为我认为这会节省时间。如何在分配时使用需要参数的构造函数初始化动态分配的对象数组？

class Thingy{
private:
    int* a;
public:
    Thingy(int size);
};

class ThingyLayer{
private:
    Thingy* m_things;
public:
    ThingyLayer(int n){
        m_things = new Thingy[n]; //!< How do I pass a param here to the ctor of Thingy
    }
};

在这种情况下，我不想使用std::vector，因为有一天我可能想在不支持 STL 的嵌入式系统上运行它，比如 Atmel AVR 芯片。所以我正在寻找如何使用指针来做到这一点。

我已经尝试过了，m_things = new Thingy[n](val)，但这不起作用，因为它会引发编译器警告。我还查看了Dynamically allocating an array of objects，但这并没有回答我的问题。

Answer 1

执行此操作的 C++ 方法是 std::vector（我不相信你真的有充分的理由使用指针来代替好吧，你说出了一个原因，我真的不能判断好不好用，因为我对嵌入式系统一窍不通）：

class ThingyLayer{
private:
    std::vector<Thingy> m_things;
public:
    ThingyLayer(int n) : m_things(n,val){}
};

这也使您免于手动newing 和deleteing 东西的痛苦，正确地做这不是一件有趣的事情。

std::vector 还带有一大堆其他简洁的功能，如果您不熟悉，请查看我链接的手册页。

Answer 2

您可能可以通过以下方式获得：

ThingyLayer(int n){
    char* temp = new char[sizeof(Thingy)*n];
    for (int i = 0; i < n; ++i )
    {
        // Use placement new to construct Thingy objects.
        new (temp+i*sizeof(Thingy)) Thingy(10); // Assuming 10 here.
    }
    m_things = reinterpret_cast<Thingy*>(temp);
}

我有点犹豫，因为Thingy 和char 的对齐要求不同。我不确定这会如何影响代码的行为。

如果你走这条路，ThingyLayer 的析构函数也必须精心设计。

class ThingyLayer
{
   private:
      int m_n;
      Thingy* m_things;
   public:
      ThingyLayer(int n) : m_n(n) {
         char* temp = new char[sizeof(Thingy)*n];
         for (int i = 0; i < n; ++i )
         {
            // Use placement new to construct Thingy objects.
            new (temp+i*sizeof(Thingy)) Thingy(10); // Assuming 10 here.
         }
         m_things = reinterpret_cast<Thingy*>(temp);
      }

      ~ThingyLayer()
      {
         for (int i = 0; i < m_n; ++i )
         {
            // Call the destructor of Thingy explicitly.
            m_things[i].~Thingy();
         }

         // Now deallocate the memory using a char*.
         char* temp = reinterpret_cast<char*>(m_things);
         delete [] temp;
      }

      // Make sure to implement copy constructor and copy assignment 
      // operator properly. If you use the default copy constructor and
      // copy assignment operator, the program will exhibit undefined
      // behavior.

      ThingyLayer(ThingyLayer const& copy) { ... }
      ThingyLayer& operator=(ThingyLayer const& rhs) { ... }

};

延伸阅读：What is The Rule of Three?