Newsgroup: it.comp.lang.c++
Titolo: allocazione dinamica e disallocazione

Ho scritto il seguente programmino x cercare di capire il funzionamento
degli operatori new e delete:
///////////////////////////////////////////////////////
#include <iostream.h>
int main() {
  int n, m, i, j;
 
  cout << "n. righe: ";
  cin >> n;
  cout << "n. colonne: ";
  cin >> m;
 
  int ** aa = new int *; // alloco mem. x un ptr. a interi
  for (int i = 0; i < n; i++)
    aa[i] = new int[m];  // alloco n array di interi di lunghezza m
  // in questo modo ho una matrice a[][] le cui dimensioni sono definite
  // durante l'esecuzione del programma
 
    for (i = 0; i < n; i++)
      for (j = 0; j < m; j++)
        aa[i][j] = i - j;      
    for (i = 0; i < n; i++) {
      for (j = 0; j < m; j++)i {
        cout << aa[i][j] << "\t";
      }
      cout << endl;
    }
    for (int i = 0; i < n; i++)
      delete [] aa[i];  // disalloco la memoria destinata agli
                        // n array m-dimensionali
    delete aa;   // disalloco la mem. destinata al puntatore ad interi
   return 0;
}
/////////////////////////////////////////////////////
Questo programma ha un comportamento bizzarro. Funziona senza problemi
per n < 4 e m < 5, per es. ecco l'output per n = 3 e m = 4:
n. righe: 3
n. colonne: 4
0       -1      -2      -3
1       0       -1      -2
2       1       0       -1
Per n = 4 e m = 3, invece ho un segmentation fault:
n. righe: 4
n. colonne: 3
0       -1      -2
1       0       -1
2       1       0
3       2       1
Segmentation fault
Per valori più alti ancora, non mi viene nemmeno stampata a video la
matrice:
n. righe: 10
n. colonne: 10
Segmentation fault
Dove sbaglio?
Uso il compilatore GNU:
gcc version 2.95.2 20000220 (Debian GNU/Linux)
-- 
Davide Cavallari

"Davide Cavallari" ha scritto:
che ne pensate di questa come FAQ?
o gia' c'e'?

 Dove sbaglio?
Vedi sopra
--
Andrea Ferro
---------
Brainbench C++ Master. Scored higher than 97% of previous takers
Scores: Overall 4.46, Conceptual 5.0, Problem-Solving 5.0
More info 
http://www.brainbench.com/transcript.jsp?pid=2522556

 che ne pensate di questa come FAQ?
La domanda come posta no di certo. Una domanda (anche costruita) sugli
array bidimensionali direi di si.


 array bidimensionali direi di si.
logico che la mia proposta fosse da intendersi in questa maniera

che ne pensate di questa come FAQ?
dove trovo le FAQ?
grazie
-- 
Davide Cavallari

  int ** aa = new int*[n]; // alloco mem. per n ptr. a interi
E' vero!
Un ultimo chiarimento..
Quando scrivo qualcosa del genere:
float x[5];  // array a 5 elementi
float* ptr;
ptr = x;       //  <=> ptr = &x[0]
*ptr = 1.5;  // ora x[0] = 1.5
*(ptr + 1) = 2.5; // x[1] = 2.5
*(ptr + 3) = 3.5; // x[3] = 3.5
cosa avviene a livello di memoria?
float x[5]: viene allocata memoria per contenere 5 float.
float* ptr: viene allocata memoria per 1 puntatore a float, giusto?
Perciò, se scrivessi:
*(ptr + n) = 4.2,   con n >= 5
andrei a scrivere su locazioni di memoria successive a quelle allocate
per l'array x[5] e il comportamento del programma sarebbe indefinito,
come leggevo in un altro thread sugli array.
Concludendo, (ptr + k) con (k != 0) non esiste a livello di locazione di
memoria, esiste solo ptr; (ptr + k) si ottiene andando a vedere il
contenuto di ptr (un indirizzo di una locazione di memoria) e spostandosi 
di k locazioni di memoria in avanti.
Ho capito?
-- 
Davide Cavallari

 Ho capito?
Non del tutto. La somma fra puntatore e intero ti da un puntatore dello
stesso tipo ... purchè resti all'interno dell'array puntato o al massimo
sfori di uno in avanti (quest'ultimo puntatore è valido ma non
dereferenziabile).
Inoltre nota che scrivere "ptr+n" non significa spostarsi in avanti di
due locazioni ma di due oggetti. Cioè di n*sizeof(*ptr) locazioni di
memoria.


 dove trovo le FAQ?
Su 
cpp.programmazione.it
E questa, purtroppo, è una FAQ.


 E questa, purtroppo, è una FAQ.
ricorsiva :)
infatti se stai gia' leggendo le faq la risposta puo' solo essere 
"qui", altrimenti devi cercarle :)