Newsgroup: it.comp.lang.c
Titolo: c99 e dimensione array

visto che mi sto avvicinando adesso al c99, mi pare aver letto che il c99
prevede la possibilità di avere array la cui dimensione non è nota in
fase di compilazione.
Esistono questi array?
Se sì, come si comportano questi array? posso aumentare dinamicamente la
loro dimensione a runtime senza perdere i dati?

 loro dimensione a runtime senza perdere i dati?
No. Una volta che sono stati instanziati, le loro dimensioni non possono
variare.
Max

Ottavio Campana ha scritto:

I dettagli li hai già nella risposta Max M. Sintetizzo con un esempio. Gli
array dinamici ti permettono di fare cose come queste:
   void laMiaFunzione(int h, int w)
   {
       float la_mia_matrice[h][w];
      ...
   }
la_mia_matrice è una semplicissima variabile locale: l'unica particolarità
è che le sue dimensioni sono conosciute solo a runtime. Sembra una cosa da
poco ma col C89 non era possibile (le dimensioni dovevano essere costanti).
Ne approfitto per fare anch'io una domanda che mi frullava in testa da un
po'. Immagino che la risposta sia "no" ma non si sa mai...
Sarebbe possibile, in C99, dichiarare una funzione così:
   void FunzioneFolle(int h, int w, mat[h][w])
   {
      ...
   }
In altri termini, è gli ARGOMENTI di una funzione siano array dinamici?
--
Cingar
-- 
questo articolo e` stato inviato via web dal servizio gratuito 
http://www.newsland.it/news
 segnala gli abusi ad 
ab...@newsland.it

 loro dimensione a runtime senza perdere i dati?
Dichiarare sì.  Aumentare no.  


 
Non mi intendo di C99, ma mi pare che sia possibile. Nella pagina che ho 
citato nell'altro mio messaggio è riportato un esempio con un VLA 
dichiarato come argomento di una funzione. Il seguente codice viene 
accettato da GCC 3.4 (se si compila con l'opzione "-std=c99"):
 void func( int n, int m, char array[n][m] )
 {     printf("%c\n", array[3][4]);
 }
 int main()
 {
        int a = 15;
        int b = 10;
        char array[a][b];
        array[3][4] = 'A';
        func(a,b,array);
        return 0;
 }
M

 accettato da GCC 3.4 (se si compila con l'opzione "-std=c99"):
Non dedurrei la conformità allo standard C99 per il comportamento del gcc.
D'altronde, supportava i VLA, ancor prima che il C99 venisse ratificato.
Comunque è possibile (e anche plausibile, secondo me) che quel codice sia
C99-compliant.


 [ snip ]
Si... ma viene accettato anche questo codice:
void f(int i, int j, int old[i][j]){
    int i_,  j_;
    int arr[i][j];
    for (i_ = 0; i_ < i; ++i_){
        for (j_ = 0; j_ < j; ++j_){
            arr[i_][j_] = old[i_][j_] = i_ + j_;
        }
    }
}
int main(){
    int o[1][1];
    f(1000, 1000, o);
    return 0;
}
Che ovviamente da un errore grosso come una casa.
In pratica non fa il controllo di dimensione proprio, come invece farebbe 
sulle n-1 prime dimensioni di un array di array ... di array.
void f(int i, int j, int old[3][4])
per dire da errore.
In pratica quella feature imho sara` fonte di grossi bachi. 
D'altra parte se ci pensiamo e` logico.
Siccome appunto i e j non sono note a tempo di compilazione, lui si 
ritroverebbe con una funzione con argomenti non definiti (come tipo) a 
tempo di compilazione. Allora lui li ignora semplicemente (salvo volerli 
come 'segnaposto'.
-- 
[ RiK0                                ]
[ non credo negli schemi non vincenti ]
[ two is an odd prime number          ]