colocación nueva gama + + alineación

Question

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

cuando me paso más allá de estas líneas con el depurador, que me muestra los valores de las variables de amortiguación y BufferPtr:

BufferPtr: 0x0d7f004c 
Buffer: 0x0d7f0050 

Realmente no entiendo por qué esos valores diferir de. Tal como lo entiendo, la colocación nueva debe usar la memoria que comienza en la dirección 'BufferPtr' para inicializar los elementos de la matriz utilizando sus constructores predeterminados en la memoria asignada y devolver un puntero al primer byte del primer elemento de la matriz, que debería ser exactamente el mismo byte que se pasó al nuevo operador de ubicación.

¿He entendido algo mal o alguien me puede decir por qué los valores son diferentes?

gracias!

// editar: bien - he investigado la cuestión y dieron resultados más confusos:

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]; 

el depurador me devuelve los siguientes valores para mis variables:

size: 4 

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

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

por lo que claramente debe tener algo que ver con mi genérico smartpointer clase matth_ptr así que aquí está:

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 
    }; 

}; 

¿Alguien puede explicarme qué está pasando? ¡Gracias!

Answer 1

Está utilizando la versión de matriz del operador new que en su implementación está almacenando información sobre el tamaño de la matriz en los primeros bytes de la asignación de memoria.

Answer 2

Tenga cuidado con la colocación nueva en las matrices. En el aspecto estándar actual para la sección 5.3.4.12, se encuentra esta:

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

Es claro que va a esperar que el nuevo operador la colocación asignarlo espacio adicional más allá de lo contenido de la matriz necesitan. "y" se especifica solo como un valor integral no negativo. A continuación, compensará el resultado de la nueva función con esta cantidad.

Consulte también 18.4.1.3.4 donde dice que el nuevo operador de ubicación simplemente devuelve el puntero proporcionado. Esta es obviamente la parte esperada.

Basado en 5.3.4.12, dado que ese desplazamiento puede ser diferente para cada invocación de la matriz, la norma básicamente significa que no hay forma de asignar la cantidad exacta de tamaño necesaria. En la práctica, ese valor es probablemente constante y podría agregarlo a la asignación, pero su cantidad puede cambiar por plataforma, y ​​nuevamente, por invocación, como dice la norma.

Answer 3

Como han dicho otros, esto se debe a que su implementación C++ almacena el tamaño de la matriz al inicio del búfer que pasa a la colocación de la matriz nueva.

Una solución fácil para esto es simplemente asignar su puntero de matriz al búfer, luego recorrer la matriz y usar la colocación regular (no de matriz) nueva para construir cada objeto en el búfer.

Answer 4

@Mat, esta es realmente una gran pregunta. Cuando utilicé la ubicación nueva [], tuve problemas para eliminar el almacenamiento.Incluso si llamo a mi propia ubicación simétrica delete [], la dirección del puntero es no igual que mi nueva ubicación me la devolvió []. Esto hace que la ubicación nueva [] sea completamente inútil, como ha sugerido en los comentarios.

La única solución que he encontrado fue sugerida por Jonathan @: en lugar de la ubicación nueva [], use la ubicación nueva (no la matriz) en cada uno de los elementos de la matriz. Esto está bien para mí ya que almaceno el tamaño yo mismo. El problema es que tengo que preocuparme por las alineaciones de puntero para los elementos, lo que se supone que debe hacer [] para mí.