Newsgroup: it.comp.lang.c
Titolo: Inizializzazione array...una curiosita`...

Salve a tutti,
da qualche parte ho trovato scritto che  <<se il numero di elementi di 
un array è specificato, e ne viene inizializzato un numero inferiore, 
tutti quelli "mancanti" verranno inizializzati a 0 dal compilatore >>.
In effetti facendo qualche tentativo ho notato che con il mio 
compilatore tale congettura risulta verificata....
Ma cio` e` da ritenersi assolutamente valido (aderente alla specifica 
del linguaggio) oppure resta prerogativa esclusiva del mio e di pochi 
altri compilatori?
Grazie!
Inviato da 
www.mynewsgate.net


E` richiesto dallo standard. Citando la bozza:
        6.7.8  Initialization
        [...]
        [#21] If there are fewer initializers  in  a  brace-enclosed
        list  than there are elements or members of an aggregate, or
        fewer characters in a string literal used to  initialize  an
        array  of  known  size than there are elements in the array,
        the  remainder  of  the  aggregate  shall   be   initialized
        implicitly  the  same  as  objects  that have static storage
        duration.
E l'inizializzazione degli oggetti static e` effettuata in questo modo:
        [#10] If an object that has automatic  storage  duration  is
        not  initialized explicitly, its value is indeterminate.  If
        an  object  that  has  static  storage   duration   is   not
        initialized explicitly, then:
          -- if  it  has  pointer  type, it is initialized to a null
             pointer;
          -- if  it  has  arithmetic  type,  it  is  initialized  to
             (positive or unsigned) zero;
          -- if  it  is  an  aggregate,  every member is initialized
             (recursively) according to these rules;
          -- if it is a union, the first named member is initialized
             (recursively) according to these rules.
Quindi gli elementi non specificati sono effettivamente inizializzati a 
zero se sono di un tipo aritmetico, con un puntatore nullo se sono di 
tipo puntatore.
-- 
Enrico `Trippo' Porreca

 
preso dalla curiosita` ho provato quanto affermato dalla precedente 
congettura e ho scoperto che con due compilatori diversi, definendo una 
variabile union con classe di memorizzazione statica e non 
inizializzandola ottengo sempre l'inizializzazione a 'zero' dell'intera 
unione (e non solo del primo membro) ovvero del membro di dimensione 
maggiore.
Ad esempio provando con la seguente union:
typedef union myUnionDef{
	int	i;
	char	buff[32];
}myUnionUn, *myUnionPtr;
e definendo una variabile union tipo:
static	myUnionUn 	u;
 
ottengo che u risulta inizializzata a 'zero' ovvero a '\0' (come  
preferisci), fino al 32_esimo byte.
In effetti questa cosa ha il suo senso....non trovi?
"the first named member" significa esattamente quello che ho capito 
ovvero il primo membro dall'alto verso il basso?
Il tuo compilatore come si comporta? 
Ciao,
Ale
Inviato da 
www.mynewsgate.net

 ha scritto:

Un'altra domanda...quanto affermato per le variabili con classe di 
memorizzazione statica (a proposito dell'inizializzazione) vale pari pari 
anche per le variabili appartenenti all'ambiente globale (che siano 
static o extern indifferentemente)??
Dal mio punto di vista non vedo altro motivo al fatto che le variabili 
appartenenti all'ambiente locale statico debbano essere inizializzate 
a 'zero' se non quello che queste variabili appartengono gia` al file 
contenente il programma eseguibile e non vengono allocate a run-time come 
le variabili nello stack....
Cio` vale anche per le variabili appartenenti all'ambiente 
globale....quindi mi sembrerebbe logica una certa analogia anche a 
livello di linguaggio...
Ciao e grazie.
Ale 
Inviato da 
www.mynewsgate.net