Matriz con punteros

[sherry_xD]

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:

Código C:

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:

Código C:

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:

Código C:

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

Pero no se como trabajar con ellos en el main, ni dentro de la funcion, please ayuda.

[leosansan]

Es más fácil que lo veas a explicarlo.

El código es totalmente modular: se introducen las dimensiones, se asigna memoria dinámicamente , se rellenan, se multiplican y por último se libera la memoria:

Código C++:

#include <stdio.h>
 
void leer_dimen_coeficientes( const char* msg, int* pnum );
int** asig_memoria( int fil, int col );
void ver_matriz( int **mat, int fil, int col );
void introducir_matriz( const char* msg, const char* nombre, int** mat, int fil, int col );
void crear_matriz_producto( int **c,int **a,int **b,int fil, int col,int co1);
void liberar_mem_vector( int** mat, int fil );
 
int main( void )
{
    int **A;
    int fil_1, col_1;
    int **B;
    int fil_2, col_2;
    int **C;
    leer_dimen_coeficientes( "Introduce el numero de filas de A: ", &fil_1 );
    leer_dimen_coeficientes( "Introduce el numero de columnas de A: ", &col_1 );
    A = asig_memoria( fil_1, col_1 );
    introducir_matriz( "Introduce los valores de los elementos de A:\n","A", A, fil_1, col_1 );
    puts("A:");
    ver_matriz( A, fil_1, col_1 );
 
    /*leer_dimen_coeficientes( "Introduce el numero de filas de B = columnas de A: ", &fil_2 );*/
    fil_2 = col_1; /** <== condicion para que se puedan multiplicar **/
    leer_dimen_coeficientes( "Introduce el numero de columnas de B : ", &col_2 );
    B = asig_memoria( fil_2, col_2 );
    introducir_matriz( "Introduce los valores de los elementos de B:\n","B", B, fil_2, col_2 );
    puts("B:");
    ver_matriz( B, fil_2, col_2 );
 
    C= asig_memoria( fil_1, col_2 );
    crear_matriz_producto(  C,A,B, fil_1,col_2, col_1 );
    puts("AxB:");
    ver_matriz( C, fil_1, col_2 );
 
    liberar_mem_vector( A, fil_1 );
    liberar_mem_vector( B, fil_2 );
    liberar_mem_vector( C, fil_1 );
 
    return 0;
}
void leer_dimen_coeficientes( const char* msg, int* pnum )
{
   int c;
   printf( "%s", msg );
   fflush( stdout );
   scanf( "%d", pnum );
   while( (c = getchar()) != '\n' && c != EOF );
}
int** asig_memoria( int fil, int col )
{
    int i;
    int** mat;
    mat = malloc( fil * sizeof *mat );
      for( i = 0; i < fil; ++i )
         mat[i] = malloc( col * sizeof **mat );
    return mat;
}
void introducir_matriz( const char* msg, const char* nombre, int** mat, int fil, int col )
{
   int c, i, j;
   printf( "%s", msg );
   fflush( stdout );
   for( i = 0; i < fil; ++i )
      for( j = 0; j < col; ++j )
      {
         printf( "%s[%d][%d] = ", nombre, i, j );
         fflush( stdout );
         scanf( "%d", &mat[i][j] );
      }
   while( (c = getchar()) != '\n' && c != EOF );
}
void ver_matriz( int **mat, int fil, int col )
{
   int i,j;
   for( i = 0; i < fil; ++i )
   {
      for( j = 0; j < col; ++j )
         printf( "%4d ",  mat[i][j]);
      putchar('\n');
   }
}
void crear_matriz_producto( int **c,int **a,int **b,int fil1, int col2 ,int co1)
{
    int i,j,k;
    for( i = 0; i < fil1; ++i )
        for( j = 0; j < col2; ++j )
            {
                c[i][j] = 0;
                    for ( k = 0; k <co1; k++)
                        c[i][j] += a[i][k]*b[k][j];
            }
 
}
void liberar_mem_vector( int** mat, int fil )
{
   int i;
   for( i = 0; i < fil; ++i )
      free( mat[i] );
   free( mat );
}
 

¡¡¡Saluditos!!!

[vangodp]

Hasta yo voy a mirarlo ^^

[dehm]

he leido, para enviar como parametro una matriz es necesario indicar
el indice de la columna.

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...

No sé si esto es lo que quieres saber, pero si el prototipo de la función es como pones:

Código C++:

void multiplicacion(float M1[][2], float M2[][2],float M3[][2],int n);
 

Es decir, que los arrays que quieres multiplicar son de NX2, siempre puedes averiguar el valor de "n" mediante sizeof();
Así, tu llamada a la función será:

Código C++:

multiplicacion(M1,M2,M3,sizeof(M1)/sizeof(M1[0]));
 

Esto quiere decir que el tamaño de un array/el tamaño de uno de sus elementos es = al nº de elementos.

No sé si esto resuelve tus dudas. Si no es así, el código de leosansan te resuelve perfectamente el problema para arrays de cualquier dimensión.

[vangodp]

me hago un lio de pitote, jajaj os referis a columnas y filas pero es lo mismo creo que todo el raleo viene de eso XDDD
En realidad no existe columnas ni filas yo por ejemplo lo llamo asi que es como veo mejor[col, fil]

cuando paso la lonjitud de algo prefiero que sea por ejemplo la lonjitud del string imagine que tenemos un texto:
|---------fila---------------->
aaaaaaaaaaaaaaaaaaaa C
bbbbbbbbbbbbbbbbbbbb O
ccccccccccccccccccccccccccc L


¿tu que le pasas? la linea o la cantidad de palabras guardadas en cada linea? jajaj
Me tenéis un raleo mental jajaj y eso que ya había hasta entendio el tema XDDD

Ya se que no hay nombre pero uso la forma a la que realmente se organiza en memoria o eso creo.
O puede que ya no sepa nada de matrices jajaj vaya raleo mental

en la memoria es así no ?
aaaaaaaaaaaaaaaaaaaabbbbbbbbbbbbbbbbbbbbcccccccccc ccccccccccccccccc

https://www.youtube.com/watch?v=TEyLHaTFGEU

de echo cuando paso a una función debo indicar la lonjitud que tiene la primera linea: aaaaaaaaaaaaaaaaaaaa

o sea le tengo que decir el valor que tiene la X abajo


si declaro

int columna 2;
int fila 5;
int matriz [columna][fila];


Seria así como la veríamos:

[0,0][0,1][0,2][0,3][0,4]
[1,0][1,1][1,2][1,3][1,4]

realmente en memoria va así:

[0,0][0,1][0,2][0,3][0,4][1,0][1,1][1,2][1,3][1,4]

realmente todo es una fila: consecutiva en memoria.

claro esta que si llamo a columna de fila y fila de columna los nombres invierten pero en memoria seguirá siendo igual o sea que cuando la paso la matriz a una funcion le indico la lonjitud que tiene

[0,0][0,1][0,2][0,3][0,4] <-------0.4 ya que la linea de abajo es lo mismo le paso cuantas lineas tiene aparte y todo listo XD
[1,0][1,1][1,2][1,3][1,4]

corrígeme si me equivoco XD