使用参数构造函数模拟 new[]

Question

如果我没有修改参数构造函数中的任何static 变量，是否低于模拟new T[N] (x,y);（带参数的新数组）的正确方法？

template<typename T>
void* operator new [] (size_t size, const T &value)
{
  T* p = (T*) malloc(size);
  for(int i = size / sizeof(T) - 1; i >= 0; i--)
    memcpy(p + i, &value, sizeof(T));
  return p;
}

使用会，

struct A
{
  A () {}  // default
  A (int i, int j) {} // with arguments
};

int main ()
{
  A *p = new(A(1,2)) A[10];  // instead of new A[10](1,2)
}

Answer 1

我建议

 std::vector<A> v(10, A(1,2));

我意识到这并不能真正解决数组的问题。 你可以使用

 p = &v[0]; 

因为标准保证连续存储。调整矢量大小时要非常小心，因为它可能会使 p 无效

我检查了 boost::array（它适应 C 风格的数组），但它没有定义构造函数...

Answer 2

这不是好的。您正在将对象复制到未初始化的内存中，而没有调用正确的复制语义。

只要您只使用 POD，就可以了。但是，在使用不是 POD 的对象时（例如您的 A），您需要采取预防措施。

除此之外，operator new 不能以这种方式使用。正如Alexandre 在 cmets 中指出的那样，数组不会被正确初始化，因为 C++ 将在调用 operator new 之后为所有元素调用构造函数，从而覆盖这些值：

#include <cstdlib>
#include <iostream>

template<typename T>
void* operator new [] (size_t size, T value) {
    T* p = (T*) std::malloc(size);
    for(int i = size / sizeof(T) - 1; i >= 0; i--)
        new(p + i) T(value);
    return p;
}

struct A {
    int x;
    A(int x) : x(x) { std::cout << "int ctor\n"; }
    A() : x(0) { std::cout << "default ctor\n"; }
    A(const A& other) : x(other.x) { std::cout << "copy ctor\n"; }
};

int main() {
    A *p = new(A(42)) A[2];
    for (unsigned i = 0; i < 2; ++i)
        std::cout << p[i].x << std::endl;
}

这会产生：

int ctor
copy ctor
copy ctor
default ctor
default ctor
0
0

……不是预期的结果。

Answer 3

这不行 - 如果typename T 有这样的对象（在您的示例中struct A 确实有一个），C++ 将调用这些对象非平凡的默认构造函数，这将导致在已占用的内存中重建对象。

一个合适的解决方案是使用std::vector（推荐）或调用::operator new[]来分配内存，然后使用placement-new调用构造函数并处理任何异常。

Answer 4

您应该考虑到可能会调用operator new[] 来请求比sizeof(T) * n 更多的内存。

可能需要这个额外的内存，因为 C++ 必须知道在delete[] p; 的情况下要销毁多少对象，但它不能可靠地使用new p[sz] 分配的内存块的大小来推断这个数字，因为内存可能已经询问自定义内存管理器，因此（例如您的情况）仅通过知道指针无法知道分配了多少内存。

这也意味着您提供已初始化对象的尝试将失败，因为返回给应用程序的实际数组可能不会从您从自定义 operator new[] 返回的地址开始，因此初始化可能会错位。

Answer 5

template <typename myType> myType * buildArray(size_t numElements,const myType & startValue) {
  myType * newArray=(myType *)malloc(sizeof(myType)*numElements);

  if (NULL!=newArray) {
    size_t index;
    for (index=0;index<numElements;++index) {
      new (newArray+index) myType(startValue);
    }
  }

  return newArray;
}

template <typename myType> void destroyArray(size_t numElements,myType * oldArray) {
  size_t index;
  for (index=0;index<numElements;++index) {
    (oldArray+index)->~myType();
  }
  free(oldArray);
}

A * p=newArray(10,A(1,2));
destroyArray(10,p);

destroyArray 也可以这样编写，具体取决于您要构建的平台：

template <typename myType> void destroyArray(myType * oldArray) {
  size_t numElements=malloc_size(oldArray)/sizeof(myType); //or _msize with Visual Studio
  size_t index;
  for (index=0;index<numElements;++index) {
    (oldArray+index)->~myType();
  }
  free(oldArray);
}