[C] Direttiva o errore?

[linux_r]

E' possibile definire in c una direttiva del tipo

#define NOME_MACRO nome_variabile_da_leggere_da_tastiera

int main(){
     scanf("%d",nome_variabile_da_leggere_da_tastiera
     int array[NOME_MACRO]

}

Praticamente ho provato un codice simile su linux

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <pthread.h>
#include <time.h>
#define N n
int glob;

void* routine(void * arg){
    sleep(rand()%10+1);
    glob++;
    printf("\nglob = %d \n",glob);
    fflush(stdout);
    return (void *)0;

}

int main()
{
    register int i;
    int n;
    srand((unsigned int)time(NULL));
    printf("Inserisci il valore di n ");
    fflush(stdout);
    scanf("%d",&n);
    pthread_t tid[N];
    for(i=0;i<N;i++){
        pthread_create(&tid[i],NULL,routine,NULL);
    }
    for(i=0;i<N;i++){
        pthread_join(tid[i],NULL);
    }
    return 0;
}

Funziona !! com'è possibile?

[oregon]

Mi dispiace ma non ho capito nulla ... qual è la richiesta? Qual è il problema?

[linux_r]

Mi dispiace ma non ho capito nulla ... qual è la richiesta? Qual è il problema?

in poche parole in questo programma c , assegno un valore alla direttiva tramite il valore della variabile locale letta da scanf . com'è possibile ? praticamente ho ottenuto una specie di allocazione dinamica della memoria!!

#define Num n //ma n lo leggo da tastiera e uso Num per dichiarare un array nel main dopo aver letto da tastiera

int main(){
 scanf("%d",&n)
int array[Num]

}

[minomic]

Se non sbaglio, ogni volta che scrivi Num questo viene sostituito con n, e questo spiega il comportamento che descrivi.

[linux_r]

certo ma è una cosa normale?? cioè a questo punto non ci sarebbe più bisogno di malloc e calloc per l'allocazione dinamica della memoria... Se non erro è un problema di standard, ovvero ci deve essere uno standard che prevede che tutte le dichiarazioni devono essere fatte all'inizio del programma ,prima di ogni chiamata a funzione, e prima di qualsiasi altra operazione

[oregon]

Questa funzionalità si chiama

VLA (Variable-length_array)

ed è supportata da C99 (starai usando un compilatore che supporta tale caratteristica).

Standard precedenti non supportano questa funzionalità e personalmente, non la adotto.

Per approfondimenti

http://en.wikipedia.org/wiki/Variable-length_array

[MItaly]

I VLA in genere sono una pessima idea essenzialmente perché allochi sullo stack un array di dimensioni note solo a runtime; se l'array richiesto è troppo grosso (e basta poco, lo stack in genere è al più di qualche MB sui normali OS desktop) mandi in crash l'applicazione (senza alcun messaggio di errore, se sei su Windows).

[M.A.W. 1968]

I VLA sono fortemente deprecati e non devono essere usati. Si tratta, in pratica, di una feature proprietaria di GCC che (per motivi mai sufficientemente chiariti dal relativo rationale) ha trovato una via di ufficializzazione con lo standard ISO/IEC 9899:1999 (C'99), il quale peraltro anche su altri aspetti si è adagiato inspiegabilmente sulle scelte arbitrarie di GCC, vedansi gli interi a 64 bit.

Nonostante ciò, quasi nessun altro compilatore supporta i VLA, e con piena ragione. Dunque non posso che ribadire: non si deve fare ricorso ai VLA in alcun caso. Sono un'anomalia sintattica che emula costrutti possibili solo con linguaggi di alto livello, e su molte architetture sono proni a creare problemi.