[C] Ritorno di una matrice da una funzione C

[ivanet]

Salve espongo il mio problema.
Sto risolvendo un programmino sui numeri di Fibonacci in C tramite un algoritmo che si basa sui qudrati successivi, in cui utilizzo il prodotto fra matrici.
Ora, ho creato una funzione del tipo:

int **function(int m[][2]){
//istruzioni
return m;
}

All'interno di un'altra funzione ho dichiarato
int **M;
assegnandogli il ritorno della chiamata della funzione "function" dunque:
M=function(matrice);

Vorrei adesso stampare (printf("%d",....) il primo elemento di M premettendo che:
- M[0][0] non funziona
- ((*M)[0]+0) non funziona

Non so quindi se ho applicato correttamente il ritorno dalla funzione e se il modo in cui voglio stampare l'elemento è sbagliato oppure.....

Grazie!

[UltraBeginner]

[
All'interno di un'altra funzione ho dichiarato
int **M;

Forse non funziona perchè lo hai dichiarato nel posto sbagliato

Ho fatto un programmino velocissimo che funziona

int **function(int **matrice)
{
int i,y;  
 for(i=0;i<10;i++)
  {
    for(y=0;y<10;y++)
     {
      matrice[i][y]=y;   
     }
  }
return matrice;
}

int main()
{
   int **pippo=NULL,i,**pluto=NULL,y;
   
   pippo=(int **)malloc(sizeof(int*)*10);

   for(i=0;i<10;i++)
    pippo[i]=(int *)malloc(sizeof(int)*10);
   
   pluto=function(pippo);
  
   printf("%d\n\n",pluto[0][0]);   
  
   
   system("PAUSE");
   return EXIT_SUCCESS;
} 

L'accesso all elemento pluto[0][0] non genera alcun errore.

Magari se posti il tuo codice, cerchiamo di risolvere la magagna (io però ci darò un occhiata domani perchè ora esco dall'ufficio!! )

[ivanet]

Grazie innanzi tutto per la tempestività e per la completezza della pragmatica.
Per focalizzare un pò meglio la situazione ho creato un piccolo programma per il prodotto di due matrici di ordine nxn con n=2 (specifico per il mio problema).

Leggendo il tuo codice mi hai fatto notare per mezzo dell'utilizzo dell'allocazione di memoria che avevo dei problemi all'interno della funzione per il calcolo del prodotto, che però funzionava se stampavo con la sintassi M[0], M[1] ecc....
Di questo codice che ora cito mi chiedo qual è il ragionamento che sta dietro questa correttezza della stampa, cioè ... viene stampato il contenuto del puntatore di puntatore perchè M punta all'indirizzo di.... quindi facendo M[0] succede che....

Questo è il codice di simulazione

#include<stdio.h>

int **prodottomatrici(int n,int m1[][2],int m2[][2], int m3[][2]){
int **mTmp;
int i,j,k;
int somma=0;
for(i=0;i<n;i++){
for(j=0;j<n;j++){
somma=0;
for(k=0;k<n;k++)
somma+=(m1[i][k] * m2[k][j]);
m3[i][j]=somma;
}
}
return m3;
}

int main(){
int **M=NULL,i;

int m1[2][2]={2,3,2,1};
int m2[2][2]={3,5,9,6};
int m3[2][2]={0,0,0,0};

M=prodottomatrici(2,m1,m2,m3);
printf("%d",M[0]);
system("PAUSE");
return 0;
}

mentre questo è il codice seguendo la tua linea (penso si possa fare di meglio per inizializzare quelle matrici!!!)

#include<stdio.h>
int **prodottomatrici(int n,int **m1,int **m2, int **m3){
m1[0][0]=2;
m2[0][0]=3;
m3[0][0]=0;

m1[0][1]=3;
m2[0][1]=5;
m3[0][1]=0;

m1[1][0]=2;
m2[1][0]=9;
m3[1][0]=0;

m1[1][1]=1;
m2[1][1]=6;
m3[1][1]=0;

int i,j,k;
int somma=0;
for(i=0;i<n;i++){
for(j=0;j<n;j++){
//m3[i][j]=0.0;
somma=0;
for(k=0;k<n;k++)
somma+=(m1[i][k] * m2[k][j]);
m3[i][j]=somma;
}
}
return m3;
}

int main(){
int **m1,**m2,**m3,**M=NULL,i;
m1=(int **)malloc(sizeof(int*)*10);
m2=(int **)malloc(sizeof(int*)*10);
m3=(int **)malloc(sizeof(int*)*10);

for(i=0;i<2;i++){
m1[i]=(int *)malloc(sizeof(int)*10);
m2[i]=(int *)malloc(sizeof(int)*10);
m3[i]=(int *)malloc(sizeof(int)*10);
}

M=prodottomatrici(2,m1,m2,m3);
printf("%d",M[1][0]);

system("PAUSE");
return 1;
}

Nel primo il risultato è stato ottenuto in modo fortunoso, nell'altro più ragionato.
Tu sai darmi qualche spiegazione?
Ti ringrazio nuovamente!

[UltraBeginner]

We,

int m1[2][2]={2,3,2,1};

inizializzando la matrice cosi e come se inizializzassi un vettore..quindi ocho!!! l'argomento non è dei più facili!

[ivanet]

Si grazie! Un errore grave scappato per la fretta.....
Ho modificato un pò le cose ma adesso in qualche modo vorrei creare questa situazione:
1. Creare dinameicamente una matrice
2. Passarla alla funzione già inzializzata
3. Restituirla

Per il punto 1 ed il punto 2 ci siamo.
Cerco invece di trovare una soluzione con meno linee di codice per inizializzare il puntatore di puntatore a degli elementi che conosco senza usare cicli, cioè ad esempio come se inizializzassi appunto la matrice int m[2][2]={{2,1},{3,4}}.

Risolto (spero) questo problema potrò finalmente aggiungere tutto al calcolo per Fibonacci.
A risultato ottenuto ti mostrerò questo algoritmo senza intoppi (spero sempre)!

Grazie per la pazienza perchè sono consapevole che questo argomento non è dei più semplici!

[UltraBeginner]

Originariamente inviato da ivanet
Si grazie! Un errore grave scappato per la fretta.....
Ho modificato un pò le cose ma adesso in qualche modo vorrei creare questa situazione:
1. Creare dinameicamente una matrice
2. Passarla alla funzione già inzializzata
3. Restituirla

Per il punto 1 ed il punto 2 ci siamo.
Cerco invece di trovare una soluzione con meno linee di codice per inizializzare il puntatore di puntatore a degli elementi che conosco senza usare cicli, cioè ad esempio come se inizializzassi appunto la matrice int m[2][2]={{2,1},{3,4}}.

Risolto (spero) questo problema potrò finalmente aggiungere tutto al calcolo per Fibonacci.
A risultato ottenuto ti mostrerò questo algoritmo senza intoppi (spero sempre)!

Grazie per la pazienza perchè sono consapevole che questo argomento non è dei più semplici!

Uhm direi che senza usare cicli non resta che inizizializzarla con m[2][2]={{2,1},{3,4}}. etc....

[ivanet]

Beh, prova a vedere questo piccolo codice, non lo compila.....se uso questa semplice inizializzazione.
Ma è sbaglaiata, perchè va bene che sto usando una 2x2 come matrice ma pensiamo se fosse una 10x10 di cui so già i valori !?!
Può essere che ho dei problemi io a compilarlo? (Spero che a te non dia problemi)


#include<stdio.h>
int main(){
int **m3,i;
m3=(int **)malloc(sizeof(int*)*2);
for(i=0;i<2;i++)
m3[i]=(int *)malloc(sizeof(int)*2);
m3[2][2]={{0,0},{0,0}};
printf("%d",m[0][0]);
system("PAUSE");
return 0;
}

A presto e grazie!

[UltraBeginner]

Originariamente inviato da ivanet
Beh, prova a vedere questo piccolo codice, non lo compila.....se uso questa semplice inizializzazione.
Ma è sbaglaiata, perchè va bene che sto usando una 2x2 come matrice ma pensiamo se fosse una 10x10 di cui so già i valori !?!
Può essere che ho dei problemi io a compilarlo? (Spero che a te non dia problemi)


#include<stdio.h>
int main(){
int **m3,i;
m3=(int **)malloc(sizeof(int*)*2);
for(i=0;i<2;i++)
m3[i]=(int *)malloc(sizeof(int)*2);
m3[2][2]={{0,0},{0,0}};
printf("%d",m[0][0]);
system("PAUSE");
return 0;
}

A presto e grazie!

Ola Iva,

l'inizializzazione del tipo m3[2][2]={{0,0},{0,0}} funziona quando fai appunto una inizializzazione di matrice del tipo

int pluto[2][2]={{0,0},{0,0}}; in cui dici al compilatore di allocare la memoria per una matrice 2*2 per poi metterci i tuoi valori.

Invece nel nostro caso con

m3=(int **)malloc(sizeof(int*)*2);
for(i=0;i<2;i++)
m3[i]=(int *)malloc(sizeof(int)*2);

crei lo spazio in memoria per la matrice mentre l inizializzazione deve avvenire con dei cicli successivi.

int **m3,i,j;
m3=(int **)malloc(sizeof(int*)*2);    // Allocazione vettore di puntatori a puntatori
for(i=0;i<2;i++)
 m3[i]=(int *)malloc(sizeof(int)*2);  // Allocazione vettore di puntatori a int

for(i=0;i<2;i++)   // Inizializzazione
 {
  for(j=0;j<2;j++)  
    m3[i][j]=0;
 }

printf("%d",m3[0][0]);
system("PAUSE");
return 0; 

Come al solito, se hai bisogno, siamo qua!! Saluti!!

[ivanet]

Cioè questo significa che devo usare per forza dei cicli e se voglio impostare all'interno dei cicli i valori della matrice che già conosco devo andare ad inserire un bel pò di if e se proprio la voglio forse fare pulita, utilizzare un vettore in cui carico i valori e poi giocare all'interno dei for per gestire l'inizializzazione?
Che ne pensi?

[UltraBeginner]

Originariamente inviato da ivanet
Cioè questo significa che devo usare per forza dei cicli e se voglio impostare all'interno dei cicli i valori della matrice che già conosco devo andare ad inserire un bel pò di if e se proprio la voglio forse fare pulita, utilizzare un vettore in cui carico i valori e poi giocare all'interno dei for per gestire l'inizializzazione?
Che ne pensi?

Uhm posto che i valori della matrice li sai a priori (o almeno cosi mi pare di capire lol) possiamo decidere se acquisirli da tastiera o da file. Che ne pensi?