Newsgroup: it.comp.lang.c
Titolo: inizializzazione di una matrice

ciao a tutti...vorrei sottoporvi un problema che mi si è presentato
programmando in C. Il codice consiste in un main al cui interno si richiama
una funzione, più o meno la struttura è questa
#include....
.......
.......
char *puncturing(... , int bitrate, ....); //prototipo della funzione
void main ()
{
.....
datapunct=puncturing(... , 128000, ...);
.....
}
char *puncturing(... , int bitrate, ....){ //definizione della funzione
.....
//codice
}
Il problema che ho è il seguente: all'interno della funzione puncturing vado
a definire una matrice i cui elementi dipendono dal valore del parametro
bitrate che viene dato in ingresso alla funzione stessa (ovvero bitrate
compare all'interno della matrice). Chiaramente compilando mi viene dato un
errore "Initializer must be constant" perchè va a inizializzare una matrice
i cui elementi dipendondo da un valore non noto. Come posso risolvere il
problema? Avevo pensato di inizializzare la matrice con le giuste dimensioni
ma lasciandola vuota e andare a riempirla poi successivamente (a quel punto
bitrate sarebbe noto perchè la funzione è stata chiamata dal main) però poi
è possibile fare un assegnamento globale? Cioè se inizializzo
int matrice[2][2]
poi come posso riempire in un colpo la matrice senza andare a lavorare campo
per campo (visto che la matrice reale è bel + grossa)? Cioè io vorrei poi
fare una cosa del tipo
matrice={{1,2},{3,4}};
ma ovviamente non si può :(
Qualche anima pia che ha qualche idea da darmi? grazie mille!
--------------------------------
Inviato via 
http://arianna.libero.it/usenet/

 ma ovviamente non si può :(
non credo proprio si possa fare nulla del genere. 
Ma a che cavolo ti serve questa matrice?
Ciao
Giuseppe

ciao! grazie per la risposta...provo a spiegarmi meglio...il problema che ho
io è che le variabili compaiono all'interno della matrice in fase di
inizializzazione, cioè io ho una cosa del tipo:
char *puncturing(... , int bitrate, ....){ //definizione della funzione
int matrice[4][4]={{(bitrate*24/32000)-3,3,10,9},
				{(bitrate*24/32000)-3,3,6,5},
	        		 {(bitrate*24/32000)-3,3,4,3},
				 {(bitrate*24/32000)-3,3,2,1}};
/////
}
cioè dovrei inizializzare una matrice i cui valori dipendono dal parametro
bitrate dato in ingresso alla funzione stessa. Sicuramente potrei
inizializzarla come matrice vuota però poi dovrei riempire un elemento per
volta ed essendo la matrice reale + grossa diventa un pò un macello. Però mi
sa che non ho alternative...nel resto della funzione vado a leggere
determinati campi della matrice per effettuare delle elaborazione di
dati....


 volta ed essendo la matrice reale + grossa diventa un pò un macello.
Ma scusa se gli elementi dipendono dal parametro basta scrivere un ciclo in
cui li calcoli in automatico uno per uno.
Mi pare di capire però che una serie di elementi sulle righe sono costanti
e, se interpreto bene, il tuo problema è la scocciatura di inizializzarli a
mano con delle assegnazioni.
Supponendo che la matrice reale abbia uno schema simile a quello
dell'esempio cioè l'elemento di prima colonna di ogni riga dipende dal
parametro mentre gli altri sono costanti da inserire a compile time,
potresti memorizzare la matrice in maniera dinamica per colonne invece che,
come al solito per righe.
In questo caso allochi la matrice (allocazione dinamica ovvio). Hai dunque
una array di puntatori a puntatori lungo quanto il numero di colonne della
matrice.
Allochi un'altro array per la prima colonna e calcoli i valori da inserire
in base al parametro. 
Ora il punto critico...
Dichiari ed allochi staticamente una matrice con n righe e m-1 colonne dove
memorizzi i valori costanti con un'assegnazione come nell'esempio.
Infine associ alle colonne della matrice principale con indice superiore a
zero, le righe (o le colonne dipende dalla tua implementazione) della
matrice statica che hai inizializzato nella maniera rapida.
Io ho provato questo codice e funziona
int main(){
        int i,j;
        int sm[3][4] ={{1,1,1,1},{2,2,2,2},{3,3,3,3}};
        int** m = (int**)malloc(sizeof(int*)*4);
        m[0] = (int*)malloc(sizeof(int)*4);
        for (i=0; i<4; i++)
                m[0][i]=i;
        m[1] = sm[0];
        m[2] = sm[1];
        m[3] = sm[2];
 
        for (j=0; j<4; j++){
                for (i=0; i<4; i++)
                        printf("%d ",m[i][j]);
                printf("\n");
        }                       
}
Tuttavia c'è da stare attenti in fase di rilascio della memoria. Free
funziona correttamente solo se chiamata su un puntatore restituito da
malloc.
Inoltre non è detto che la matrice statica sia proprio allocata come array
di puntatori ad array, credo dipenda dal compilatore che usi.
Infine attenzione a come usi la matrice inizializzata in questo modo, nota
che nel ciclo di stampa ho invertito gli indici di riga e colonna rispetto
alla solita visita per righe. In effetti, però, è ancora una visita per
righe! Solo che m[i][j] è l'elemento j-esima riga, i-esima colonna!
Ciao e Buono studio
Giuseppe
P.S. Dimenticavo, attento che questa maniera un pò storta di usare le
matrici è inefficiente.


grazie mille della risposta! Proverò a fare come dici tu...in realtà i campi
dipendenti dal parametro non sono solo sulla prima colonna ma sparsi anche
in altre posizioni...l'alternativa (che forse è la cosa + semplice) come
dicevi era inizializzare la matrice magari ponendo a 0 i campi che dipendono
dal parametro e poi andare a riempirli uno per uno (è un pò una scocciatura
xè la matrice è grossa e i campi che dipendono dal parametro parecchi)...cmq
ti ringrazio molto per la disponibilità!
