Foro de elhacker.net

Hola, estoy haciendo una funcion que multiplica dos matrices de orden n;
como he leido, para enviar como parametro una matriz es necesario indicar
el indice de la columna.
Ejemplo:

void multiplicacion(float M1[][2], float M2[][2],float M3[][2],int n){
   //cosas
}
 

Sin embargo, la idea es que este valor sea variable, por lo que no sabria el valor que deberia ir ahi. Al parecer la solucion seria utilizar punteros ._____. La verdad es que no se mucho de punteros, o en realidad no se manejarlos .-.
Mi programa ,sin los punteros es este:

void multiplicacion(float M1[][2], float M2[][2],float M3[][2],int n){
     int i,j,k;
    float a,b;
    for (i=0;i < n; i++){
        for (j=0; j < n; j++){
             M3[i][j] = 0.0;
            for(k=0; k < n; k++){   
                 a= M1[i][k];
                b= M2[k][j];
                M3[i][j] +=( a*b); 
             }
                 printf("%f  ", M3[i][j]);
         }
         printf("\n");
     }  
}
int main(){
     int i,j;
     float M1[2][2]= { {2.0,3.0},
                     {2.0,3.0} };
    float M2[2][2]= { {3.0,2.0},
                     {3.0,2.0} };
    float M3[2][2];
        multiplicacion(M1,M2,M3,2);
    for (i=0 ; i < 2 ; i++){
        for (j=0; j< 2 ; j++){
            printf("%f  ", M3[i][j]);
        }
        printf("\n");
    }
    return 0;
}
 

Por favor, alguien que me diga como deberia quedar con punteros.
Se que la funcion deberia recibir los parametros asi:

void multiplicacion(float **M1, float **M2,float **M3,int n){
     // cosas
}
 

Prueba a poner ese prototipo y corre tu programa. Te llevarás una sorpresa.

Saludos.

Hola, primero gracias por responder :D!

Probe asi como me dijiste pero me tira muchas warnings, que dicen basicamente que el tipo de puntero es incompatible, y al ejecutarlo, me dice violacion de segmento ('core' generado)

Me ayudas please  :huh:  :huh:

Si quieres que las matrices sean de tamaño variable tienes dos opciones:

opción 1: Añades a la firma de la función un par "filas-columnas" por cada una de las 3 matrices ( o bien asumes que la matriz donde almacenas el resultado va a tener el tamaño correcto )

void multiplicacion(float **M1, int filasM1, int colsM1, float **M2, int filasM2, int colsM2, float **M3, int filasM3, int colsM3 );

opción 2: Creas una estructura para facilitar la gestión de las matrices y así te aseguras que las dimensiones de cada matriz viajan siempre junto a la matriz:

typedef struct
{
  float** datos;
  int filas;
  int columnas;
} Matriz;
 
void multiplicacion( Matriz* M1, Matriz* M2, Matriz* M3 )
{
  int i,j,k;
  float a,b;
 
  // Se comprueba que las matrices se puedan multiplicar ( falta comprobar M3 )
  if ( M1->columnas != M2->filas )
    return;
 
  for (i=0; i < M3->filas; i++)
  {
    for (j=0; j < M3->columnas; j++)
    {
      M3->datos[ i ][ j ] = 0.0;
      for(k=0; k < M1->columnas; k++)
      {   
        a = M1->datos[ i ][ k ];
        b = M2->datos[ k ][ j ];
        M3->datos[ i ][ j ] += ( a * b ); 
      }
    printf( "%f  ", M3[ i ][ j ] );
  }
  printf( "\n" );
}

Obviamente, en este caso, las matrices son dinámicas, por lo que tendrás que reservar la memoria necesaria para poder construir las matrices... en este caso lo recomendable es crear una función que permita inicializar dichas matrices y otra para liberar la memoria:

 
void EliminarMatriz( Matriz* m )
{
  if ( m->filas > 0 && m->columnas > 0 )
  {
    int i;
    for ( i = 0; i < m->filas; i++ )
      free( m->datos[ i ];
 
    free( m->datos );
  }
 
  m->filas = 0;
  m->columnas = 0;
  m->datos = 0;
}
 
void InicializarMatriz( Matriz* m, int filas, int columnas )
{
  if ( filas == 0 || columnas == 0 )
  {
    filas = 0;
    columnas = 0;
  }
 
  m->filas = filas;
  m->columnas = columnas;
 
  if ( filas > 0 )
  {
    matriz.datos = (float**)calloc( filas, sizeof( float* ) );
 
    int i;
    for ( i = 0; i < filas; i++ )
      matriz.datos[ i ] = (float*)calloc( columnas, sizeof( float ) );
  }
}

Con estas funciones auxiliares, la creación y eliminación de matrices se convierte en algo trivial.