passaggio di matrici in C

[white05]

Dunque il mio problema è questo. Spero di spiegarmi bene.
Ho un main che ha una matrice [n][n] .... la matrice deve essere passata ad una function che ne estrae solo dei valori e li mette su un'altra matrice di tipo [3][n]
Fin qui tutto bene.
Il mio problema è... come faccio a ripassare la nuova matrice generata nella function al main per farla poi stampare?

esempio...

main(){
....
....
nuovamatrice (matrix); //gli passo la matrice

for(i=0;i<3;i++){
for(j=0;j<n;j++){

printf("%f", newmatrix[i][j]); /*dove newmatrix dovrebbe essere la matrice generata dalla function*/
}
}

void nuovamatrice(float a[n][n]){

/*faccio lo scambio degli elementi e li metto in una matrice che per esempio chiamo m*/
for......
m[i][j+1]=a[i][j]; //è solo un esempio

}

come passo m al main per farlo stampare come newmatrix?

Grazie

[mostec]

la fai restituire dalla funzione come doppio puntatore al tipo di dato della matrice..

es: float** funzione(float matrix[][])

dentro questa funzione allochi DINAMICAMENTE(quindi con malloc ecc.) la matrice, elabori quello che devi fare, e restituisci il doppio puntatore che punta alla matrice con return..


es:

float **funzione (float matrix[][])
{
    float **matriceNUOVA;
    // ALLOCHI E ELABORI I DATI
   return matriceNUOVA
}
void main()
  {
    float matrice[BOH?][BOH?];
    float **risultato;
    risultato=funzione(matrice);
}

questa è una visuale un po' vaga se ti servono particolari informazioni anche su dynamic matrix (quindi tutto il modo per allocare e preparare la matrice allocata dinamicametne), chiedi pure....


Ciao.

[dnarod]

per curiosita interessa anche a me, mi basta un input sull allocazione (malloc)

[andbin]

Originariamente inviato da mostec

es: float** funzione(float matrix[][])

È bene precisare alcune cose:

(1)
È perfettamente possibile avere una matrice bidimensionale dichiarata come float**. Bisogna però far notare che non è un vero e proprio array come inteso dal "C". In "C" un array è "una collezione di elementi del medesimo tipo organizzata in memoria in modo contiguo".
Dichiarando float** è possibile avere una matrice bidimensionale solo per il fatto che si avrà alla fine "un array di array". Cioè punterà ad un array in cui ogni elemento è un puntatore ad un altro array.
Per allocare un array bidimensionale di questo tipo si fa in questo modo (ometto i controlli di errore, per brevità):

int dimensione1 = 4;
int dimensione2 = 6;
float **matrice;
int i;

matrice = (float**) malloc (dimensione1 * sizeof (float*));

for (i = 0; i < dimensione1; i++)
    matrice[i] = (float*) malloc (dimensione2 * sizeof (float));

In questo modo la matrice, come dimensionalità, è sicuramente a 2 dimensioni ma non è un array nel senso stretto del "C".
Questo metodo, tra l'altro, consente di creare matrici bidimensionali non rettangolari, dette anche "jagged" array (proprio come in Java, per esempio).
Naturalmente, alla fine dell'utilizzo, bisogna poi deallocare ogni singolo sotto-array e anche l'array principale.

(2)
Per passare ad una funzione un "vero" array bidimensionale (es. funzione(float matrice[][])), è necessario e obbligatorio specificare almeno la seconda dimensione.
Esempio:
float** funzione(float matrice[][6])
Questo comporta il fatto che non si può passare ad una funzione un "vero" array bidimensionale in maniera generica, cioè con qualunque dimensione n x m. Se n'era già parlato, tra l'altro, in questo thread.

[white05]

Senti poiché non posso usare malloc esiste un altro metodo??
GRAZIE MILLE

[mostec]

in alternativa se le dimensioni della matrice nuova le sai prima della chiamata alla funzione puoi dichiararla nel main e passarla come parametro nella funzione.

visto che array e matrici si passano sempre per riferimento alla chiusura della funzione ti troveresti la matrice nuova con i dati elaborati.


altri modi senza l'uso di allocazione dinamica non te ne saprei dire..

[andbin]

Originariamente inviato da white05

Senti poiché non posso usare malloc esiste un altro metodo??
GRAZIE MILLE

Per quale motivo, se posso chiedere, non puoi usare la malloc? Non puoi usare in modo specifico la malloc o in generale non puoi usare alcun tipo di allocazione dinamica???

Comunque senza allocazioni dinamiche (malloc e simili), non puoi fare molto per creare matrici di dimensioni "generiche" (cioè stabilite a run-time). Puoi solo creare e usare array e matrici di dimensione nota a priori (cioè conosciuta a tempo di compilazione del sorgente).
Esempio:

void funzione (float matrice_input[6][6], float matrice_output[3][6])
{
    ....
}

int main (void)
{
    float matrice_a[6][6];
    float matrice_b[3][6];

    ....

    funzione (matrice_a, matrice_b);

    return 0;
}

[white05]

si non devo usare allocazioni dinamiche, infatti il mio problema era più che altro far ritornare la matrice... le dimensioni le ho già.. ho messo n come numero generico

[andbin]

Originariamente inviato da white05

si non devo usare allocazioni dinamiche, infatti il mio problema era più che altro far ritornare la matrice... le dimensioni le ho già.. ho messo n come numero generico

Non necessariamente devi "far ritornare" una matrice. Questo andrebbe bene se nella funzione allochi dinamicamente una nuova matrice, ovviamente quindi da restituire in qualche modo al chiamante!

Nel sorgente che ho postato io, non viene "restituita" alcuna matrice. Nel main dichiari le 2 matrici (a e b) e poi riempi la matrice a. Nella funzione opererai sulla matrice "input" e scriverai su quella "output". Quando ritorni nel main, la matrice b contiene il risultato. Questo perché alla funzione hai passato i puntatori alle matrici.

[Gandalf_BD]

Un altro modo (non molto bello e nemmeno consigliato, a dir la verità ) è quello di dichiarare la matrice come variabile globale...
in questo modo non devi passare nessun parametro alla tua funzione...
cmq, come già detto, è una soluzione che è meglio evitare...
giusto?

[andbin]

Originariamente inviato da Gandalf_BD

Un altro modo (non molto bello e nemmeno consigliato, a dir la verità ) è quello di dichiarare la matrice come variabile globale...
in questo modo non devi passare nessun parametro alla tua funzione...
cmq, come già detto, è una soluzione che è meglio evitare...
giusto?

Beh secondo me ... dipende! Una cosa non necessariamente è sempre giusta o sempre sbagliata.
Dipende molto da cosa deve fare con la matrice e dal contesto della applicazione. Se la matrice deve essere gestita da molte funzioni e magari ha un "significato" globale (cioè contiene dati che servono in modo globale alla applicazione e per tutto il tempo di esecuzione), allora questa soluzione potrebbe essere accettabile.

Nel caso di white05, mi sembra di capire che abbia bisogno di una semplice funzione che prende in input una matrice, la elabora e scrive il risultato su una matrice in "output". In questo caso renderla globale solo per risparmiare 1 parametro ... mi sembra una stupidata. (imho, ovviamente)

[Gandalf_BD]

Originariamente inviato da andbin

In questo caso renderla globale solo per risparmiare 1 parametro ... mi sembra una stupidata. (imho, ovviamente)

beh, chiaro...
io gliel'ho proposta come una delle possibli soluzioni, ma è ovviamente (come ho scritto) preferibile evitarla