C++，没有 <vector> 的对象数组

Question

我想在 C++ 中创建一个不使用 STL 的对象数组。

我该怎么做？

如何创建没有无参数构造函数（默认构造函数）的 Object2 数组？

Answer 1

如果有问题的类型有无参数构造函数，请使用new[]：

Object2* newArray = new Object2[numberOfObjects];

当您不再需要该数组时，不要忘记致电delete[]：

delete[] newArray;

如果没有这样的构造函数，使用operator new分配内存，然后就地调用构造函数：

//do for each object
::new( addressOfObject ) Object2( parameters );

同样，不要忘记在不再需要数组时释放它。

Answer 2

假设你的类是 Base 并且你有一个单参数构造函数

Base arr[3] = {Base(0), Base(1), Base(2)} ;

Answer 3

// allocate memory
Object2* objArray = static_cast<Object2*>( ::operator new ( sizeof Object2 * NUM_OF_OBJS ) );
// invoke constuctors
for ( size_t i = 0; i < NUM_OF_OBJS; i++ )
  new (&objArray[i]) Object2( /* initializers */ );

// ... do some work

// invoke destructors
for ( size_t i = 0; i < NUM_OF_OBJS; i++ )
  objArray[i].~Object2();

// deallocate memory
::operator delete ( objArray );

Answer 4

Object2 *myArray[42];
for (int i = 0; i < 42; i++)
{
  myArray[i] = new Object2(param1, param2, ...);
}

稍后您将不得不遍历数组并单独释放每个成员：

for (int j = 0; j < 42; j++)
{
  delete myArray[j];
}

Answer 5

使用指向 Object2 的指针数组：

std::tr1::shared_ptr<Object2>* newArray = new shared_ptr<Object2>[numberOfObjects];
for(int i = 0; i < numberOfObjects; i++)
{
    newArray[i] = shared_ptr<Object2>(new Object2(params));
}

或者，或者，不使用 shared_ptr：

Object2** newArray = new Object2*[numberOfObjects];
for(int i = 0; i < numberOfObjects; i++)
{
    newArray[i] = new Object2(params);
}

Answer 6

您可以做std::vector 所做的事情并创建一块原始内存。然后，您可以使用placement new 构造在该内存中没有默认构造函数的对象，因为它们是必需的。但是，当然，如果您这样做，您不妨一开始就使用std::vector。

Answer 7

如果没有可用的默认构造函数，则需要一个指针数组，然后遍历该数组以初始化每个指针。

Answer 8

显而易见的问题是您为什么不想使用 STL。

假设您有一个理由，您将创建一个对象数组，其中包含Obj * op = new Obj[4]; 之类的内容。请记住使用delete [] op; 摆脱它。

对于没有构造函数且不带参数的对象，您无法做到这一点。在这种情况下，我认为你能做的最好的就是分配一些内存并使用新的放置。它不像其他方法那么简单。

Answer 9

如果你真的需要一个非默认可构造类型的数组（对象的连续序列），并且由于某种原因你不能让用户std::vector（！？）那么你必须使用原始分配函数和放置新的。

这很难可靠地做到；这应该有助于说明原因。这个 sn-p 包括一些对异常的防御，但很可能对所有故障都不是健壮的。

const size_t required_count = 100; //e.g.

// cast to pointer of required type needed for pointer arithmetic
Object2* objarray = static_cast<Object2*>(operator new(required_count * sizeof(Object2)));

size_t construction_count = 0;

try
{
    while (construction_count < required_count)
    {
        // params could change with index.
        new (static_cast<void*>(objarray + construction_count)) Object2(param1, param2);
        ++construction_count;
    }
}
catch (...)
{
    while (construction_count-- != 0)
    {
        try
        {
            (&objarray[construction_count])->~Object2();
        }
        catch (...)
        {
            // not a lot we can do here, log but don't re-throw.
        }
    }

    operator delete(objarray);
    throw;
}

// Now objarray has been allocated and pointer to an array of required_count Object2
// It cannot be de-allocated via delete[] or delete; you must loop through
// calling destructors and then call operator delete on the buffer.