¿Cómo inicializar la memoria con un nuevo operador en C ++?

Estoy empezando a entrar en C ++ y quiero aprender algunos buenos hábitos. Si acabo de asignar una matriz de tipos intcon el newoperador, ¿cómo puedo inicializarlos a 0 sin recorrerlos todos yo mismo? ¿Debo usar memset? ¿Hay una manera "C ++" de hacerlo?

Es una característica sorprendentemente poco conocida de C ++ (como lo demuestra el hecho de que nadie ha dado esto como respuesta todavía), pero en realidad tiene una sintaxis especial para inicializar un conjunto de valores:

new int[10]();

Tenga en cuenta que debe usar los paréntesis vacíos; no puede, por ejemplo, usar (0)ni nada más (por lo que esto solo es útil para la inicialización de valores).

Esto está explícitamente permitido por ISO C ++ 03 5.3.4 [expr.new] / 15, que dice:

Una nueva expresión que crea un objeto de tipo Tinicializa ese objeto de la siguiente manera:

...

• Si el nuevo inicializador tiene la forma (), el elemento tiene un valor inicializado (8.5);

y no restringe los tipos para los que está permitido, mientras que el (expression-list)formulario está restringido explícitamente por otras reglas en la misma sección, de modo que no permite tipos de matriz.

Suponiendo que realmente desea una matriz y no un std :: vector, la "forma C ++" sería esta

#include <algorithm> 

int* array = new int[n]; // Assuming "n" is a pre-existing variable

std::fill_n(array, n, 0); 

Pero tenga en cuenta que, en realidad, esto sigue siendo en realidad solo un bucle que asigna cada elemento a 0 (realmente no hay otra forma de hacerlo, salvo una arquitectura especial con soporte a nivel de hardware).

Hay varios métodos para asignar una matriz de tipo intrínseco y todos estos métodos son correctos, aunque cuál elegir, depende ...

Inicialización manual de todos los elementos en bucle.

int* p = new int[10];
for (int i = 0; i < 10; i++)
{
    p[i] = 0;
}

Usando la std::memsetfunción de<cstring>

int* p = new int[10];
std::memset(p, 0, sizeof(int) * 10);

Usando std::fill_nalgoritmo de<algorithm>

int* p = new int[10];
std::fill_n(p, 10, 0);

Utilizando std::vectorcontenedor

std::vector<int> v(10); // elements zero'ed

Si C ++ 0x está disponible, usando las características de la lista de inicializador

int a[] = { 1, 2, 3 }; // 3-element static size array
vector<int> v = { 1, 2, 3 }; // 3-element array but vector is resizeable in runtime

Si la memoria que está asignando es una clase con un constructor que hace algo útil, el operador new llamará a ese constructor y dejará su objeto inicializado.

Pero si está asignando un POD o algo que no tiene un constructor que inicialice el estado del objeto, entonces no puede asignar memoria e inicializar esa memoria con el operador nuevo en una operación. Sin embargo, tiene varias opciones:

1) Use una variable de pila en su lugar. Puede asignar e inicializar por defecto en un paso, de esta manera:

int vals[100] = {0};  // first element is a matter of style

2) uso memset(). Tenga en cuenta que si el objeto que está asignando no es un POD , es una mala idea memorizarlo. Un ejemplo específico es que si configura una clase que tiene funciones virtuales, eliminará la vtable y dejará su objeto en un estado inutilizable.

3) Muchos sistemas operativos tienen llamadas que hacen lo que usted desea: asignar en un montón e inicializar los datos a algo. Un ejemplo de Windows seríaVirtualAlloc()

4) Esta suele ser la mejor opción. Evite tener que manejar la memoria usted mismo. Puede usar contenedores STL para hacer casi cualquier cosa que haría con la memoria sin procesar, incluida la asignación e inicialización de una sola vez:

std::vector<int> myInts(100, 0);  // creates a vector of 100 ints, all set to zero

Sí hay:

std::vector<int> vec(SIZE, 0);

Use un vector en lugar de una matriz asignada dinámicamente. Los beneficios incluyen no tener que molestarse en eliminar explícitamente la matriz (se elimina cuando el vector se sale del alcance) y también que la memoria se elimina automáticamente incluso si se produce una excepción.

Editar: para evitar más votos negativos por parte de personas que no se molestan en leer los comentarios a continuación, debo dejar más claro que esta respuesta no dice que el vector sea siempre la respuesta correcta. Pero seguro que es una forma más C ++ que "manualmente" asegurándose de eliminar una matriz.

Ahora con C ++ 11, también hay std :: array que modela una matriz de tamaño constante (frente a un vector que puede crecer). También hay std :: unique_ptr que gestiona una matriz asignada dinámicamente (que se puede combinar con la inicialización como se responde en otras respuestas a esta pregunta). Cualquiera de esos es una forma más C ++ que manejar manualmente el puntero a la matriz, en mi humilde opinión.

std::filles unidireccional Toma dos iteradores y un valor para llenar la región. Eso, o el bucle for, sería (supongo) la forma más C ++.

Para establecer una matriz de tipos enteros primitivos en 0 específicamente, memsetestá bien, aunque puede levantar las cejas. Considere también calloc, aunque es un poco incómodo usarlo desde C ++ debido al reparto.

Por mi parte, casi siempre uso un bucle.

(No me gusta adivinar las intenciones de las personas, pero es cierto que std::vector, en igualdad de condiciones, es preferible usarlas new[]).

siempre puedes usar memset:

int myArray[10];
memset( myArray, 0, 10 * sizeof( int ));

Por lo general, para listas dinámicas de elementos, utiliza a std::vector.

En general, uso memset o un bucle para la asignación dinámica de memoria sin procesar, dependiendo de qué tan variable prevea que será esa área de código en el futuro.