2009-03-24 8 views
7

Ho una matrice molto grande che deve essere lunga 262144 elementi (e potenzialmente molto più grande in futuro). Ho provato assegnazione della matrice sullo stack in questo modo:Come posso creare un array in C++ che si trova nell'heap invece dello stack?

#define SIZE 262144 
int myArray[SIZE]; 

Tuttavia, sembra che quando provo e aggiungi elementi oltre un certo punto, i valori sono diverse quando si tenta di accedervi. Capisco che questo è perché c'è una quantità limitata di memoria nello stack, a differenza dell'heap che ha più memoria.

ho provato quanto segue senza molta fortuna (non si compila):

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

E poi ho pensato di utilizzare malloc, ma mi chiedevo se ci fosse un altro C++ modo simile di fare questo ...

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

Devo andare con malloc?

+0

cambiare "myArray [SIZE]" in "myArray" nel secondo blocco di codice. – eduffy

+3

Vijay, questa non è una questione di apprendimento della sintassi. La prima opzione è corretta, fatta eccezione per la dimensione, e la seconda opzione è un bug abbastanza comune che merita di essere menzionato. Inoltre, questo sito non aiuta anche quando qualcuno non capisce la sintassi? –

+2

Per avere un errore di sintassi in una domanda non è una cattiva domanda. –

risposta

38

Ti consigliamo di utilizzare di nuovo come tale:

int *myArray = new int[SIZE]; 

sarò anche menzionare l'altra faccia di questo, nel caso in cui ....

Dal momento che il transizione dalla pila a l'heap, dovrai anche ripulire questa memoria quando hai finito.Sullo stack, la memoria verrà automaticamente la pulizia, ma nel mucchio, avrete bisogno di eliminarlo, e sin dalla sua un array, è necessario utilizzare:

delete [] myArray; 
+0

Grande sopra e oltre le informazioni. +1 –

1

Poiché il numero non è necessariamente noto al momento della compilazione, il tipo è un puntatore:

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

Grazie a questo compila. Tuttavia, anche dopo aver usato la memoria heap, ho ancora numeri casuali alla fine del mio array dopo l'assegnazione. Qualche idea? –

+0

Non lo so. Pubblica il modo in cui assegni alla domanda, quindi tutti noi possiamo dargli un'occhiata –

1

new alloca sul mucchio.

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

Il motivo che il primo tentativo non ha funzionato è che la sintassi non è corretta. Prova questo:

int *myArray = new int[SIZE]; 
1

credo

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

dovrebbe essere

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

o meglio ancora

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

tua sintassi per l'utilizzo new era sbagliato, dovrebbe essere:

int *myArray = new int[262144]; 

è sufficiente inserire la dimensione a destra del compito.

Tuttavia, se si utilizza C++ si potrebbe voler utilizzare std::vector (che si avrà) o qualcosa come boost::scoped_array per rendere la gestione della memoria un po 'più semplice.

+0

std :: vector dovrebbe essere raccomandato, poiché è * in realtà * parte del C++, e non solo una "buona aggiunta" al linguaggio. – Tom

+0

Questo è un ottimo punto – Wilka

20

Più C modo ++ di farlo è quello di utilizzare vettore. Quindi non devi preoccuparti di cancellare la memoria quando hai finito; il vettore lo farà per te.

#include <vector> 

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

+1, ma boost :: shared_array * may * è più appropriato per array di dimensioni super che dipendono dal caso d'uso. – Functastic

+0

Sembra che il vettore sia perfetto per il suo caso. Se un array avrebbe funzionato nello stack, un vettore sostituirà l'array perfettamente. –

+0

Sì, ho considerato il vettore ... Ho appena immaginato che la matrice sarebbe stata più adatta alla memoria, ma a pensarci, non ha senso ... il vettore potrebbe anche essere più efficiente in termini di memoria, giusto? –

Problemi correlati