Problema con array dinamici

[Unrue]

Mi capita una cosa strana. Nel mio programma dichiaro un array dinamico di interi:

int*nodiaperti;

All'interno di una funzione dichiaro : nodiaperti= new int[1000];

Alla fine della funzione dealloco il tutto : delete[] nodiaperti;

Quando richiamo la seconda volta la funzione, senza uscire dal programma, l'array viene ricreato ma non è vuoto. Alcune posizioni risultano occupate da numeri interi molto grossi. Ma perchè? Se dealloco l'array e lo rialloco, dovrebbe essere vuoto o sbaglio?

[VICIUS]

Non vorrei dire una cavolata ma la new non "pulisce" la zona di memoria allocata quindi ti restituisce un indirizzo di memoria valido che può essere pieno di robaccia. Sta a te ripulirla prima di cominciare ad usarla.

ciao

[Unrue]

Originariamente inviato da VICIUS

Non vorrei dire una cavolata ma la new non "pulisce" la zona di memoria allocata quindi ti restituisce un indirizzo di memoria valido che può essere pieno di robaccia. Sta a te ripulirla prima di cominciare ad usarla.

ciao

Pensavo che questo compito lo facesse il delete[] . Pero' scusa, se devo azzerare tutto il vettore per riusarlo, perdo il vantaggio dell'allocazione dinamica.
Dichiarando int*nodiaperti = new int[1000] e magari uso solo 500 posti, gli altri 500 li risparmierei. Invece, se sono costretto ad azzzerare tutti e 1000 gli elementi, è come avere un array statico di 1000 elementi.

[Angus]

Originariamente inviato da Unrue

Pensavo che questo compito lo facesse il delete[] . Pero' scusa, se devo azzerare tutto il vettore per riusarlo, perdo il vantaggio dell'allocazione dinamica.
Dichiarando int*nodiaperti = new int[1000] e magari uso solo 500 posti, gli altri 500 li risparmierei. Invece, se sono costretto ad azzzerare tutti e 1000 gli elementi, è come avere un array statico di 1000 elementi.

Forse hai le idee un pò confuse. Per come la dichiari, nodiaperti è una variabile puntatore ad int. A questa variabile assegni l'indirizzo del primo elemento dell'array allocato staticamente (!) tramite l'operatore new. Quest'ultimo ha semplicemente trovato e riservato un'area consecutiva di memoria sufficientemente grande per contenere 1000 interi.

DISCLAIMER: non tocco C++ da troppo tempo ormai, ti conviene attendere qualche risposta più 'autorevole'.

[VICIUS]

Originariamente inviato da Unrue

Pensavo che questo compito lo facesse il delete[] .

Il compito della delete e dire al sistema operativo che il tuo programma non ha piu bisogno di quella memoria.

Originariamente inviato da Unrue

Pero' scusa, se devo azzerare tutto il vettore per riusarlo, perdo il vantaggio dell'allocazione dinamica.
Dichiarando int*nodiaperti = new int[1000] e magari uso solo 500 posti, gli altri 500 li risparmierei. Invece, se sono costretto ad azzzerare tutti e 1000 gli elementi, è come avere un array statico di 1000 elementi.

Il vantaggio della allocazione dinamica è che puoi allocare a tempo di esecuzione il numero esatto di elementi che ti servono. Se conosci a priori il numero di elementi che ti servono non ha senso usare l'allocazione dimanica. Se ti servono 372 elementi ne allochi 372, li azzeri per stare sicuro e poi li usi.

ciao

[71104]

Originariamente inviato da Unrue

Mi capita una cosa strana. Nel mio programma dichiaro un array dinamico di interi:

int*nodiaperti;

All'interno di una funzione dichiaro : nodiaperti= new int[1000];

Alla fine della funzione dealloco il tutto : delete[] nodiaperti;

Quando richiamo la seconda volta la funzione, senza uscire dal programma, l'array viene ricreato ma non è vuoto. Alcune posizioni risultano occupate da numeri interi molto grossi. Ma perchè? Se dealloco l'array e lo rialloco, dovrebbe essere vuoto o sbaglio?

vuol dire che usi Visual C++; ho indovinato? niente di grave comunque, vai di memset.

[Unrue]

Originariamente inviato da Angus

Forse hai le idee un pò confuse. Per come la dichiari, nodiaperti è una variabile puntatore ad int. A questa variabile assegni l'indirizzo del primo elemento dell'array allocato staticamente (!) tramite l'operatore new. Quest'ultimo ha semplicemente trovato e riservato un'area consecutiva di memoria sufficientemente grande per contenere 1000 interi.

DISCLAIMER: non tocco C++ da troppo tempo ormai, ti conviene attendere qualche risposta più 'autorevole'.

Scusa se mi permetto ma l'operatore new non serve proprio per allocare dinamicamente qualcosa?. Se scrivo:

int*a= new int[10] a punta al primo indirizzo dell'array dinamico di interi.

Io non so a priori quanti elementi avrà questo array. Tale array cresce man mano che il programma avanza e ce li aggiunge. Io vorrei che al massimo mi occupasse 1000 posti,senza allocarli subito, quindi se alla fine ne ha utilizzati 500, gli altri 500 non li deve aver allocati. Non so se questo vuol dire memoria dinamica.

[Unrue]

Originariamente inviato da 71104

vuol dire che usi Visual C++; ho indovinato? niente di grave comunque, vai di memset.

No, sto usando Borland C++ Builder 6

[Unrue]

Originariamente inviato da VICIUS

Il compito della delete e dire al sistema operativo che il tuo programma non ha piu bisogno di quella memoria.


Il vantaggio della allocazione dinamica è che puoi allocare a tempo di esecuzione il numero esatto di elementi che ti servono. Se conosci a priori il numero di elementi che ti servono non ha senso usare l'allocazione dimanica. Se ti servono 372 elementi ne allochi 372, li azzeri per stare sicuro e poi li usi.

ciao

Certo, questo lo so. Ma non so quanti elementi avro', per questo la uso

[71104]

Originariamente inviato da Unrue

No, sto usando Borland C++ Builder 6

aaargh
non avevo considerato la Borland

be' comunque la stessa cosa in determinati casi capita anche col VC++

ciao

[Unrue]

Originariamente inviato da 71104

aaargh
non avevo considerato la Borland

be' comunque la stessa cosa in determinati casi capita anche col VC++

ciao

Mi sai dire se, quando scrivo int*a= new int[1000]
se alloco dinamicamente un'array di interi? Perchè sopra mi hanno detto che cosi' l'allocazione è statica. Ma allora a cosa serve l'operatore new quando do' una dimensione fissa all'array? New serve solo quando la dimensione non è specificata subito ma durante l'esecuzione?

Del tipo : int*a= new int[dim] e dim gli e la do' successivamente in fase di esecuzione, per esempio come input da tastiera.

[shinya]

Originariamente inviato da Unrue

Mi capita una cosa strana. Nel mio programma dichiaro un array dinamico di interi:

int*nodiaperti;

All'interno di una funzione dichiaro : nodiaperti= new int[1000];

Alla fine della funzione dealloco il tutto : delete[] nodiaperti;

Quando richiamo la seconda volta la funzione, senza uscire dal programma, l'array viene ricreato ma non è vuoto. Alcune posizioni risultano occupate da numeri interi molto grossi. Ma perchè? Se dealloco l'array e lo rialloco, dovrebbe essere vuoto o sbaglio?

La new allora uno spazio in memoria pari a quello che specifichi. Ma non puoi anche costringerla ad inizializzare tutta la memoria che alloca. Cosa vorresti ci fosse dentro? Tutti 0? Tutti 1? La new alloca la memoria, poi sta a te inizializzarla.
Se vuoi fare tutto in un colpo, in questo modo inizializzi tutto a zero:

nodiaperti = new int[1000]();

Altra cosa: e' buona norma poi mettere a zero il puntatore dopo la delete.

delete[] nodiaperti;
nodiaperti = 0;

[Unrue]

Originariamente inviato da shinya

La new allora uno spazio in memoria pari a quello che specifichi. Ma non puoi anche costringerla ad inizializzare tutta la memoria che alloca. Cosa vorresti ci fosse dentro? Tutti 0? Tutti 1? La new alloca la memoria, poi sta a te inizializzarla.
Se vuoi fare tutto in un colpo, in questo modo inizializzi tutto a zero:

nodiaperti = new int[1000]();

Altra cosa: e' buona norma poi mettere a zero il puntatore dopo la delete.

delete[] nodiaperti;
nodiaperti = 0;

Quindi scrivere int*nodiaperti = new int[1000],

equivale a scrivere int a[1000];

int*nodiaperti= &a; ? Quindi è come fare l'allocazione statica se ho ben capito. Pero' io volevo che mi allocasse un elemento per volta , man mano che lo inserivo. Non tutti in un colpo. Per esempio, io credo che i vector facciano cosi, perchè si puo' dichiarare senza specificare le dimensioni, e poi inserire gli elementi con la pushback. In tal modo, alloca un elemento per volta, suppongo.

[71104]

Originariamente inviato da Unrue

Mi sai dire se, quando scrivo int*a= new int[1000]
se alloco dinamicamente un'array di interi? Perchè sopra mi hanno detto che cosi' l'allocazione è statica. Ma allora a cosa serve l'operatore new quando do' una dimensione fissa all'array? New serve solo quando la dimensione non è specificata subito ma durante l'esecuzione?

Del tipo : int*a= new int[dim] e dim gli e la do' successivamente in fase di esecuzione, per esempio come input da tastiera.

così è dinamica:

int *a = new int[1000];
int *b = new int[dim];

e così è statica:

int a[1000];

inoltre alcuni compilatori (come il gcc) ti permettono anche di scrivere cose tipo

int b[dim];

ma sono veramente orribbili con due B.

[shinya]

Originariamente inviato da Unrue

Quindi scrivere int*nodiaperti = new int[1000],

equivale a scrivere int a[1000];

int*nodiaperti= &a; ? Quindi è come fare l'allocazione statica se ho ben capito.

Al massimo equivale a:

int a[10];
int *b = a; // dove 'a' equivale a &a[0]

E non è come l'allocazione statica, perchè puoi allocare memoria "su richiesta". E' chiaro che poi entrambe allocano memoria.

Originariamente inviato da Unrue

Pero' io volevo che mi allocasse un elemento per volta , man mano che lo inserivo. Non tutti in un colpo. Per esempio, io credo che i vector facciano cosi, perchè si puo' dichiarare senza specificare le dimensioni, e poi inserire gli elementi con la pushback. In tal modo, alloca un elemento per volta, suppongo.

Da quel che mi pare di capire, una lista sarebbe più pertinente come struttura.

[Unrue]

Originariamente inviato da 71104

così è dinamica:

int *a = new int[1000];
int *b = new int[dim];

Pero' scusa, se scrivo :

int *a = new int[1000];

cosa c'e' di dinamico? La dimensione dell'array è fissata a priori.

[Angus]

Nessuno ha ancora precisato una cosa, di cui non sono più tanto sicuro:

int a[1000]; // alloca un array di 1000 interi nello stack
int* b = new int[1000]; // alloca un array di 1000 interi nello heap

[Unrue]

Originariamente inviato da Angus

Nessuno ha ancora precisato una cosa, di cui non sono più tanto sicuro:

int a[1000]; // alloca un array di 1000 interi nello stack
int* b = new int[1000]; // alloca un array di 1000 interi nello heap

Si, questo è vero. pero' continuo a non capire cosa ci sia di dinamico se scrivo
int* b = new int[1000] . Io per dinamico intendo che l'allocazione la posso fare durante l'esecuzione. Se mi alloca subito 1000 interi non vedo cosa cambi dal punto di vista dell'occupazione di memoria, a parte che una scrive nello stack e l'altra nell'heap.

[84seawolf]

Prima di risponderti premetto che non ho ancora letto le altre risposte che ti hanno dato...quindi è probabile che hai già risolto il problema. Cmq...
Quello che accade è questo:

Con l'operatore delete non cancelli il contenuto della memoria; ciò che fa l'operatore delete è la seguente cosa:
restituisce al sistema la memoria precentemente occupata dalla variabile (la dealloca); ciò vuol dire che in qualche modo è come se si avvertisse il programma che lo spazio precedentemente occupato non serve + e quindi può essere nuovamente usato e sovrascritto.
Fai attenzione a quello che ho detto: SOVRASCRITTO!!!
questo significa che è possibile addirittura recuperare le informazioni contenute in una variabile (o array) precedentemente deallocate che non sono state ancora sovrascritte.
Probabilmente i "numeri interi molto grossi" che vedi sono informazioni contenute in quell'area di memoria che non servono +.

Prima di concludere vorrei dirti un'altra cosa:
per l'allocazione dinamica della memoria (e in particolare per creare array dinamici) esistono le STL (Standard template Library) che sono MOOOOLTO efficienti e facili da usare. come disse il mio prof. di programmazione: "è inutile inventarsi ogni volta la ruota".

Spero che questo messaggio ti è stato d'aiuto!

[Unrue]

Originariamente inviato da 84seawolf

Prima di concludere vorrei dirti un'altra cosa:
per l'allocazione dinamica della memoria (e in particolare per creare array dinamici) esistono le STL (Standard template Library) che sono MOOOOLTO efficienti e facili da usare. come disse il mio prof. di programmazione: "è inutile inventarsi ogni volta la ruota".

Spero che questo messaggio ti è stato d'aiuto!

Si lo so, infatti ho usato anche la classe template vector