安置新 +数组对齐

Question

SomeObj<unsigned int>* Buffer;
char* BufferPtr = MemoryManager::giveMeSomeBytes(resX*resY*sizeof(SomeObj<unsigned int>));
Buffer = new(BufferPtr) SomeObj<unsigned int>[resX*resY];

当我使用调试器跳过这些行时，它会显示变量 Buffer 和 BufferPtr 的值：

BufferPtr: 0x0d7f004c
Buffer:    0x0d7f0050

我真的不明白为什么这些值不同。按照我的理解，放置 new 应该使用从地址 'BufferPtr' 开始的内存，使用分配的内存上的默认构造函数来初始化数组元素，并返回指向数组中第一个元素的第一个字节的指针，这应该是与传递给放置新运算符的字节完全相同。

我是否理解错误，或者有人可以告诉我为什么价值观不同？

谢谢！

//编辑：好的 - 我进一步调查了这个问题，得到了更令人困惑的结果：

    int size = sizeof(matth_ptr<int>);

    char* testPtr1 = (char*)malloc(a_resX*a_resY*sizeof(int));
    int* test1 = new(testPtr1) int[a_resX*a_resY];

    char* testPtr2 = mmgr::requestMemory(a_resX*a_resY*sizeof(int));
    int* test2 = new(testPtr2) int[a_resX*a_resY];

    char* testPtr3 = (char*)malloc(a_resX*a_resY*sizeof(matth_ptr<int>));
    matth_ptr<int>* test3 = new(testPtr3)matth_ptr<int>[a_resX*a_resY];

    char* testPtr4 = mmgr::requestMemory(a_resX*a_resY*sizeof(matth_ptr<int>));
    matth_ptr<int>* test4 = new(testPtr4)matth_ptr<int>[a_resX*a_resY];

调试器返回我的变量的以下值：

size: 4

testPtr1:0x05100418
test1:   0x05100418
testPtr2:0x0da80050
test2:   0x0da80050

testPtr3:0x05101458
test3:   0x0510145c
testPtr4:0x0da81050
test4:   0x0da81054

所以它显然必须与我的通用智能指针类 matth_ptr 有关，所以这里是：

template <class X> class matth_ptr
{
public:
    typedef X element_type;

    matth_ptr(){
        memoryOfst = 0xFFFFFFFF;
    } 

    matth_ptr(X* p) 
    {
        unsigned char idx = mmgr::getCurrentChunkIdx();
        memoryOfst = (int)p-(int)mmgr::getBaseAddress(idx);
        assert(memoryOfst<=0x00FFFFFF || p==0);//NULL pointer is not yet handled
        chunkIdx = idx;
    }
    ~matth_ptr()                {}
    X& operator*()              {return *((X*)(mmgr::getBaseAddress(chunkIdx)+(memoryOfst&0x00FFFFFF)));}
    X* operator->()             {return  ((X*)(mmgr::getBaseAddress(chunkIdx)+(memoryOfst&0x00FFFFFF)));}
    X* get()                    {return  ((X*)(mmgr::getBaseAddress(chunkIdx)+(memoryOfst&0x00FFFFFF)));}


    template<typename T>
    matth_ptr(const matth_ptr<T>& other) {memoryOfst=other.memoryOfst;}//put these two operators into the private part in order to prevent copying of the smartpointers
    template<typename T>
    matth_ptr& operator=(const matth_ptr<T>& other) {memoryOfst = other.memoryOfst; return *this;}
    template<typename T>
    friend class matth_ptr;
private:

    union //4GB adressable in chunks of 16 MB
    {
        struct{
            unsigned char padding[3]; //3 bytes padding
            unsigned char chunkIdx; //8 bit chunk index
        };
        unsigned int memoryOfst; //24bit address ofst
    };

};

任何人都可以解释一下我这是怎么了？谢谢！

Answer 1

在数组上放置 new 时要小心。在当前标准的第 5.3.4.12 节中，您会发现这一点：

new(2,f) T[5] results in a call of operator new[](sizeof(T)*5+y,2,f)

很明显，它会期望放置 new 运算符为其分配超出数组内容所需的额外空间。 “y”仅指定为非负整数值。然后它将把新函数的结果偏移这个量。

另请参阅 18.4.1.3.4，其中表示放置 new 运算符仅返回提供的指针。这显然是预期的部分。

基于 5.3.4.12，由于每次调用数组时该偏移量可能不同，因此该标准基本上意味着无法分配所需的确切大小。在实践中，该值可能是恒定的，您可以将其添加到分配中，但他的数量可能会根据平台的不同而变化，并且按照标准的规定，每次调用也会发生变化。

Answer 2

您正在使用 new 运算符的数组版本，该运算符在您的实现中将有关数组大小的信息存储在内存分配的前几个字节中。

Answer 3

@Mat，这实际上是一个很好的问题。当我使用放置 new[] 时，我在删除存储时遇到了问题。即使我调用自己的对称放置delete[]，指针地址也与我自己的放置new[]返回的指针地址不相同。正如您在评论中所建议的那样，这使得放置 new[] 完全无用。

我找到的唯一解决方案是 Jonathan@ 建议的：不要在数组的每个元素上使用放置 new[]，而是使用放置 new （非数组）。这对我来说很好，因为我自己存储尺寸。问题是我必须担心元素的指针对齐，而 new[] 应该为我做。

Answer 4

正如其他人所说，这是由于您的 C++ 实现将数组的大小存储在您传递给数组放置新的缓冲区的开头。

解决这个问题的一个简单方法是简单地将数组指针分配给缓冲区，然后循环数组并使用常规（非数组）放置 new 来构造缓冲区中的每个对象。