2009-03-24 13 views
7

Tengo una matriz muy grande que debe tener 262144 elementos de longitud (y potencialmente mucho más grande en el futuro). He tratado de asignar la matriz en la pila, así:¿Cómo creo una matriz en C++ que está en el montón en lugar de la pila?

#define SIZE 262144 
int myArray[SIZE]; 

Sin embargo, parece que cuando intento y añadir elementos a partir de cierto punto, los valores son diferentes cuando trato de acceder a ellos. Entiendo que esto se debe a que solo hay una cantidad limitada de memoria en la pila, a diferencia del montón que tiene más memoria.

he intentado lo siguiente sin mucha suerte (no se compila):

#define SIZE 262144 
int *myArray[SIZE] = new int[SIZE]; 

Y entonces considerado el uso de malloc, pero me preguntaba si había una manera más C++ como de hacer esto ...

#define SIZE 262144 
int *myArray = (int*)malloc(sizeof(int) * SIZE); 

¿Debo simplemente seguir con malloc?

+0

cambie "myArray [SIZE]" a "myArray" en su segundo bloque de código. – eduffy

+3

Vijay, esta no es una cuestión de aprender la sintaxis. La primera opción es correcta, excepto por el tamaño, y la segunda opción es un error bastante común que merece mención. Además, ¿este sitio no trata también de ayudar cuando alguien no entiende la sintaxis? –

+2

Tener un error de sintaxis en una pregunta no lo convierte en una mala pregunta. –

Respuesta

38

Usted querrá utilizar las nuevas como por ejemplo:

int *myArray = new int[SIZE]; 

que mencionar también el otro lado de esta, por si acaso ....

Debido a que su transición de la pila de el montón, también necesitarás limpiar esta memoria cuando hayas terminado con ella.En la pila, la memoria de forma automática la limpieza, pero en el montón, se le deberá eliminarlo, y desde su una matriz, debe utilizar:

delete [] myArray; 
+0

Excelente por encima y más allá info. +1 –

1

medida que el número no es necesariamente conocido en tiempo de compilación, el tipo es un puntero:

int *myArray = new int[262144]; 
+0

Gracias que compila. Sin embargo, incluso después de usar la memoria Heap, todavía tengo números al azar al final de mi matriz después de la asignación. ¿Algunas ideas? –

+0

No lo sé. Publique la forma en que asigne a la pregunta, para que todos podamos echarle un vistazo –

1

new asigna en el montón.

#define SIZE 262144 
int * myArray = new int[SIZE]; 
0

La razón por la que el primer intento no funcionó es que la sintaxis es incorrecta. Prueba esto:

int *myArray = new int[SIZE]; 
1

creo

#define SIZE 262144 
int *myArray[SIZE] = new int[262144]; 

debería ser

#define SIZE 262144 
int *myArray = new int[262144]; 

o mejor aún

#define SIZE 262144 
int *myArray = new int[SIZE]; 
0

Su sintaxis para utilizar new estaba mal, que debe ser:

int *myArray = new int[262144]; 

solo tiene que poner el tamaño a la derecha de la asignación.

Sin embargo, si está utilizando C++, puede utilizar std::vector (que tendrá) o algo así como boost::scoped_array para facilitar la administración de la memoria.

+0

std :: vector debe recomendarse también, ya que es * en realidad * parte de C++, y no solo una "muy buena adición" a la idioma. – Tom

+0

Ese es un muy buen punto – Wilka

20

Cuanto más C manera ++ de hacerlo es utilizar vector. Entonces no tiene que preocuparse por borrar la memoria cuando haya terminado; vector lo hará por ti.

#include <vector> 

std::vector<int> v(262144); 
+0

+1, pero boost :: shared_array * may * puede ser más apropiado para arreglos de gran tamaño según el caso de uso. – Functastic

+0

Parece que el vector es perfecto para su caso. Si una matriz hubiera funcionado en la pila, un vector reemplazará perfectamente la matriz. –

+0

Sí, consideré el vector ... Acabo de pensar que la matriz sería mejor para la memoria, pero pensar en eso, eso no tiene sentido ... el vector puede ser incluso más eficiente en memoria, ¿no? –

Cuestiones relacionadas