Ciao, ragazzi ! Ho terminato un progetto (abbastanza lungo) in C in cui devo compiere diverse operazioni sulle matrici attraverso l'utilizzo di una lista di liste (in cui andranno solo elementi di tipo float), non ho alcun problema nella compilazione. Quando eseguo il programma inserisco i dati all'interno della matrice, ma nel momento in cui si esegue la trasposta, vengono stampati tanti 0 quanti sono gli elementi, non sto riuscendo a capire dove sia l'errore, credo nella funzione di stampa stampaMatrice().
Provo a postare qui parte del codice, perché è davvero lungo :

main.c :

codice:
 

main() { 
//......................................................................	
//TRASPOSTA DI UNA MATRICE
//......................................................................

  printf("*** TRASPOSTA DI UNA MATRICE ***\n\n\n");
  
  Matrice a;
  Matrice a_t;
  
//INIZIALIZZAZIONE MATRICE DI PARTENZA
  printf("Inizializzazione della matrice di partenza (MATRICE A)\n\n");  
  inizializzaMatrice( &a, acquisisciDimensione("Inserire il numero di righe: "), acquisisciDimensione("Inserire il numero di colonne: ") ); 
  acquisisciValori( &a, leggiRighe(a), leggiColonne(a) );
 
//INIZIALIZZAZIONE TRASPOSTA  
  inizializzaMatrice( &a_t, leggiColonne(a), leggiRighe(a) );
  trasposta(a, &a_t);

//STAMPA DELLE MATRICI
  printf("\n\nMATRICE\n");
  stampaMatrice( &a, leggiRighe(a), leggiColonne(a) );
  printf("MATRICE TRASPOSTA\n");
  stampaMatrice( &a_t, leggiRighe(a_t), leggiColonne(a_t) );
funzioni.h :

codice:
 

typedef struct Elemento_lista { 
        float valore; 
        struct Elemento_lista *successivo; 
} Elemento_lista;  

typedef struct Elemento_lista Nodo_lista;
typedef struct Elemento_lista *Elem_lista; 

typedef struct Elemento_lista_puntatori { 
        Elem_lista valore;
        struct Elemento_lista_puntatori *successivo_lista;
} Elemento_lista_puntatori; 

typedef struct Elemento_lista_puntatori Nodo_lista_puntatori; 
typedef struct Elemento_lista_puntatori *Elem_lista_puntatori; 

typedef struct Matrice { 
        int numero_righe;
        int numero_colonne;
        Elem_lista_puntatori val;  
} Matrice;
        
typedef enum { FALSE, TRUE } boolean; 

 
// FUNZIONI MATRICE
int acquisisciDimensione(char []); 
int leggiRighe(Matrice);
int leggiColonne(Matrice);
void scriviRighe(Matrice *, int); 
void scriviColonne(Matrice *, int);
void inizializzaMatrice(Matrice *, int, int); 
void acquisisciValori(Matrice *, int, int);
float leggiMatrice(Matrice, int, int); 
void scriviMatrice(Matrice *, int, int, float); 
void stampaMatrice(Matrice *, int, int);  
boolean controlloProd(int, int); 
float acquisisciScalare();

void trasposta(Matrice, Matrice *); 

// FUNZIONI LISTA   
void* inizializzaLista(); 
int listaVuota(Elem_lista);
int listaPuntatoriVuota(Elem_lista_puntatori);   
Elem_lista_puntatori inserimentoListaPuntatori(Elem_lista_puntatori, int, int);     
Elem_lista leggiLista(Elem_lista, int, int); 
Elem_lista_puntatori leggiListaPuntatori(Elem_lista_puntatori, int, int); 

Elem_lista inserimentoLista(Elem_lista, int, int, float);
funzioni.c :

codice:
 

float val;

int acquisisciDimensione(char s[]) {  
    int num; 
    
    printf("%s", s);
    scanf("%d", &num);
    
    return num;
}   

int leggiRighe (Matrice m) { 
    return m.numero_righe;
}
    
int leggiColonne (Matrice m) { 
    return m.numero_colonne;
} 

void scriviRighe(Matrice *m, int r) { 
     m->numero_righe = r;
} 
     
void scriviColonne(Matrice *m, int c) { 
     m->numero_colonne = c;
} 

void inizializzaMatrice(Matrice *m, int r, int c) { 
     int i;
     
     scriviRighe(m, r);
     scriviColonne(m, c);
     
     m->val = inizializzaLista(); 
} 

void acquisisciValori(Matrice *m, int r, int c) { 
     int i, j;
     
     printf("\nInserisci i valori della matrice separati da uno spazio;\n");
     printf("Premi invio al termine di ogni riga;\n\n");
     
     for(i = 0; i < r; i++) { 
           for(j = 0; j < c; j++) { 
                 scanf("%f", &val); 
                   scriviMatrice(m, i, j, val); 
		   }  
     }          
} 

float leggiMatrice(Matrice m, int r, int c) {    
      Elem_lista_puntatori dato; 
      Elem_lista puntatore_valore;   
                 
	  dato = leggiListaPuntatori(m.val, r, 0); 
      puntatore_valore = leggiLista(dato->valore, c, 0);   
	  
      return puntatore_valore->valore;  
}   
      
void scriviMatrice(Matrice *m, int r, int c, float val) { 
     Elem_lista_puntatori dato; 
     
     dato = leggiListaPuntatori(m->val, r, 0); 
     
     if(dato == NULL) 
       m->val = inserimentoListaPuntatori(m->val, r, 0); 
       
         dato = leggiListaPuntatori(m->val, r, 0); 
         dato->valore = inserimentoLista(dato->valore, c, 0, val);   
}   

void stampaMatrice(Matrice *m, int r, int c) { 
     int i, j;
	
	for(i = 0; i < r; i++) { 
          for(j = 0; j < c; j++) { 
                printf( "%5.2f ", leggiMatrice(*m, i, j) );    
          } 
          printf("\n");
    }
    printf("\n\n");
} 

boolean controlloProd (int m, int n) {  
        boolean c = FALSE;
	
	    if(m == n) 
          c = TRUE;
	
          return c; 
} 

float acquisisciScalare() { 
      float scal;
	
      printf("Inserire di seguito un valore scalare: "); 
	  scanf("%f", &scal); 
	  
	  return scal;
}   


void* inizializzaLista() {  
      return NULL; 
}  

int listaVuota(Elem_lista lista) {  
    if(lista == NULL)
      return 1;
        else
		  return 0;
}

int listaPuntatoriVuota(Elem_lista_puntatori lista) { 
    if(lista == NULL) 
      return 1; 
       else 
         return 0; 
} 

Elem_lista_puntatori inserimentoListaPuntatori(Elem_lista_puntatori lista, int posizione, int posizione_corrente) {   
  Elem_lista_puntatori dato;  
  
    if( listaPuntatoriVuota(lista) ) { 
      dato = (Elem_lista_puntatori)malloc( sizeof(Nodo_lista_puntatori) ); 
      dato->valore = inizializzaLista(); 
      dato->successivo_lista = NULL; 
		       
      return dato; 
    } else { 
              if(posizione_corrente == posizione) { 
                dato = (Elem_lista_puntatori)malloc( sizeof(Nodo_lista_puntatori) );  
                dato->valore = inizializzaLista();  
                dato->successivo_lista = lista->successivo_lista; 
                lista->successivo_lista = dato; 
			           
                return lista; 
              } else { 
                        posizione_corrente++; 
                        lista->successivo_lista = inserimentoListaPuntatori(lista->successivo_lista, posizione, posizione_corrente);  
			
                        return lista;
                }
      }                        
} 

Elem_lista leggiLista(Elem_lista lista, int posizione, int posizione_corrente) {  
           if( listaVuota(lista) ) 
             return lista; 
	           else { 
		               if(posizione_corrente == posizione) 
			             return lista;  
		                   else { 
			                       posizione_corrente++;
			                       lista = leggiLista(lista->successivo, posizione, posizione_corrente); 
			
			                       return lista;
		                   }	
			   }
}

Elem_lista_puntatori leggiListaPuntatori(Elem_lista_puntatori lista, int posizione, int posizione_corrente) {  
  if( listaPuntatoriVuota(lista) ) 
    return lista; 
      else { 
              if(posizione_corrente == posizione) 
                return lista;  
                  else { 
                          posizione_corrente++;
                          lista = leggiListaPuntatori(lista->successivo_lista, posizione, posizione_corrente); 
			
                          return lista;
                  }	
      }
} 

void trasposta(Matrice m, Matrice *m_t) { 
     int i, j;
	
	 for(i = 0; i < leggiRighe(*m_t); i++) { 
           for(j = 0; j < leggiColonne(*m_t); j++) { 
                 scriviMatrice( m_t, i, j, leggiMatrice(m, j, i) ); 
		   }
	 }     
} 

Elem_lista inserimentoLista(Elem_lista lista, int posizione, int posizione_corrente, float val) {  
           Elem_lista dato; 
           
           if( listaVuota(lista) ) { 
               dato = (Elem_lista)malloc( sizeof(Nodo_lista) ); 
		       dato->valore = val; 
		       dato->successivo = NULL; 
		       
		       return dato; 
	       } else { 
		             if(posizione_corrente == posizione) { 
                       dato = (Elem_lista)malloc( sizeof(Nodo_lista) );  
			           dato->valore = val; 
			           dato->successivo = lista->successivo; 
			           lista->successivo = dato; 
			           
			           return lista; 
		             } else { 
			                   posizione_corrente++; 
			                   lista->successivo = inserimentoLista(lista->successivo, posizione, posizione_corrente, val); 
			
                               return lista;
		               }
	         }
}
Spero qualcuno mi aiuterà, grazie per la pazienza.