¿Se puede utilizar la colocación nueva para matrices de forma portátil?

Question

¿Es posible utilizar la ubicación nueva en el código portátil cuando se usa para arreglos?

Parece que el puntero que obtiene de nuevo [] no es siempre el mismo que la dirección que ingresa (5.3.4, la nota 12 en el estándar parece confirmar que esto es correcto), pero no lo hago Veamos cómo puede asignar un búfer para que entre la matriz si este es el caso.

El siguiente ejemplo muestra el problema. Compilado con Visual Studio, este ejemplo resulta en daños en la memoria:

#include <new> 
#include <stdio.h> 

class A 
{ 
    public: 

    A() : data(0) {} 
    virtual ~A() {} 
    int data; 
}; 

int main() 
{ 
    const int NUMELEMENTS=20; 

    char *pBuffer = new char[NUMELEMENTS*sizeof(A)]; 
    A *pA = new(pBuffer) A[NUMELEMENTS]; 

    // With VC++, pA will be four bytes higher than pBuffer 
    printf("Buffer address: %x, Array address: %x\n", pBuffer, pA); 

    // Debug runtime will assert here due to heap corruption 
    delete[] pBuffer; 

    return 0; 
} 

En cuanto a la memoria, el compilador parece estar usando los cuatro primeros bytes de la memoria intermedia para almacenar un recuento del número de elementos que contiene. Esto significa que debido a que el buffer es solo sizeof(A)*NUMELEMENTS grande, el último elemento de la matriz se escribe en el montón no asignado.

Entonces, la pregunta es ¿puede averiguar cuánto sobrecarga adicional quiere su implementación para poder usar la ubicación nueva [] de forma segura? Idealmente, necesito una técnica que sea portátil entre diferentes compiladores. Tenga en cuenta que, al menos en el caso de VC, la sobrecarga parece diferir para diferentes clases. Por ejemplo, si elimino el destructor virtual en el ejemplo, la dirección devuelta desde el nuevo [] es la misma que la dirección que paso.

Answer 1

Personalmente, me gustaría ir con la opción de no utilizar la ubicación nueva en la matriz y en su lugar utilizar la colocación nueva en cada elemento de la matriz de forma individual. Por ejemplo:

int main(int argc, char* argv[]) 
{ 
    const int NUMELEMENTS=20; 

    char *pBuffer = new char[NUMELEMENTS*sizeof(A)]; 
    A *pA = (A*)pBuffer; 

    for(int i = 0; i < NUMELEMENTS; ++i) 
    { 
    pA[i] = new (pA + i) A(); 
    } 

    printf("Buffer address: %x, Array address: %x\n", pBuffer, pA); 

    // dont forget to destroy! 
    for(int i = 0; i < NUMELEMENTS; ++i) 
    { 
    pA[i].~A(); 
    }  

    delete[] pBuffer; 

    return 0; 
} 

Independientemente del método que utilice, asegúrese de destruir manualmente cada uno de los elementos de la matriz antes de eliminar pBuffer, ya que podría terminar con fugas;)

Nota : No he compilado esto, pero creo que debería funcionar (estoy en una máquina que no tiene un compilador de C++ instalado). Todavía indica el punto :) Espero que ayude de alguna manera!

---

Editar:

La razón por la que necesita para realizar un seguimiento del número de elementos es para que pueda recorrer a través de ellos cuando se llama a borrar en la matriz y asegúrese de que los destructores son llamados en cada una de los objetos. Si no sabe cuántos hay, no podría hacer esto.

Answer 2

Creo que gcc hace lo mismo que MSVC, pero por supuesto esto no t hacerlo "portátil".

creo que puede solucionar el problema cuando numElements es de hecho un tiempo de compilación constante, así:

typedef A Arr[NUMELEMENTS];

A* p = new (buffer) Arr;

Esto debería utilizar la colocación escalar nuevas.

Answer 3

De forma similar a como usaría un solo elemento para calcular el tamaño para una ubicación nueva, use una matriz de esos elementos para calcular el tamaño requerido para una matriz.

Si necesita el tamaño para otros cálculos donde no se conoce el número de elementos, puede usar sizeof (A [1]) y multiplicar por el número de elementos requeridos.

e.g

char *pBuffer = new char[ sizeof(A[NUMELEMENTS]) ]; 
A *pA = (A*)pBuffer; 

for(int i = 0; i < NUMELEMENTS; ++i) 
{ 
    pA[i] = new (pA + i) A(); 
} 

Answer 4

Gracias por las respuestas. Usar la ubicación nueva para cada elemento en la matriz fue la solución que terminé usando cuando me topé con esto (lo siento, debería haberlo mencionado en la pregunta). Simplemente sentí que debía haber algo que me faltaba al hacerlo con la colocación nueva []. Tal como está, parece que la colocación nueva [] es esencialmente inutilizable gracias al estándar que permite al compilador añadir una sobrecarga adicional no especificada a la matriz. No veo cómo podrías usarlo de manera segura y portátil.

Ni siquiera estoy realmente claro por qué necesita los datos adicionales, ya que no llamaría a eliminar [] en la matriz de todos modos, así que no veo por qué necesita saber cuántos elementos hay en ella .

Answer 5

@ James

Ni siquiera soy muy claro por qué necesita los datos adicionales, ya que no sería llamar a delete [] en la matriz de todos modos, así que no veo del todo por lo que necesita para saber cuántos artículos hay en él.

Después de pensar en esto, estoy de acuerdo contigo. No hay ninguna razón por la cual la ubicación nueva deba almacenar la cantidad de elementos, porque no hay eliminación de ubicación. Como no hay eliminación de ubicación, no hay ninguna razón para la colocación nueva para almacenar la cantidad de elementos.

También he probado esto con gcc en mi Mac, usando una clase con un destructor. En mi sistema, la ubicación nueva era no cambiando el puntero. Esto me hace preguntarme si esto es un problema de VC++, y si esto podría violar el estándar (el estándar no aborda específicamente esto, hasta donde puedo encontrar).

Answer 6

@Derek

5.3.4, el artículo 12 habla de la sobrecarga de asignación de matriz y, a menos que esté leyendo mal, parece sugerir a mí que es válido para el compilador para agregarlo en la colocación de nuevo también:

Esta sobrecarga puede aplicarse en todas las expresiones nuevas de matriz, incluidas las que hacen referencia al operador de función de biblioteca new [] (std :: size_t, void *) y otras funciones de asignación de ubicación. La cantidad de sobrecarga puede variar de una invocación de nueva a otra.

Dicho esto, creo VC fue el único compilador que me dio problemas con esto, fuera de él, GCC, y Codewarrior ProDG. Sin embargo, tendría que volver a verificar para estar seguro.

Answer 7

Colocación nueva en sí es portátil, pero los supuestos que tome acerca de lo que hace con un bloque de memoria especificada no son portátiles. Al igual que lo que se dijo antes, si fuera un compilador y se le diera un trozo de memoria, ¿cómo sabría cómo asignar una matriz y destruir adecuadamente cada elemento si todo lo que tuviera fuera un puntero? (Ver la interfaz del operador delete [].)

Editar:

Y hay realmente eliminar una ubicación, sólo que sólo se invoca cuando un constructor lanza una excepción, mientras que la asignación de una matriz con la colocación de nueva [].

Ya sea nuevo [] realmente necesita para realizar un seguimiento del número de elementos de alguna manera es algo que se deja a la norma, lo que deja en manos del compilador. Lamentablemente, en este caso.