Multiplicacion de Matrices en C++

Esta entrada es un poco más simple que Multiplicacion de matrices en C , en la cual se presentan las matrices impresas, pero espero que también sea más fácil de entender. Estos ejercicios no tienen nada que ver con las soluciones a los problemas de Deitel porque no aparecen en el libro, sin embargo sí es un ejercicio obligado, y como lo he escrito lo subo por si a alguien le resulta útil. Si quiere multiplicar matrices de tamaño arbitrario entonces sólo hay que modificar las constantes M, N y P.

#include <iostream>
using namespace::std;
#define M 2 // Hay que modificar estas entradas para
#define N 3 // cambiar el tamanio de las matrices
#define P 4

// Este programa multiplica una matriz de N filas por M columnas
// con una de M filas por P columnas

/////////////////////////////////////////////////////////////
//FUNCION RECIBE_ENTRADAS1
/////////////////////////////////////////////////////////////

void Recibe_Entradas1( int Matriz[][M])

{ // Abre funcion Recibe_Entradas1

cout << "\nAqui se reciben las entradas de la primera matriz. " << endl;
cout << "De " << N << " filas y " << M << " columnas. " << endl << endl;

for ( int i = 0; i < N; i++ )
for ( int j = 0; j < M; j++ )

{ // Abre for
cout << "Introduzca el renglon " << i + 1 << " y la columna " << j + 1 << endl;
cin >> Matriz[i][j];
} // Cierra for
} // Cierra funcion Recibe_Entradas1

////////////////////////////////////////////////////////////////////////////
// ABRE FUNCION RECIBE_Entradas2
///////////////////////////////////////////////////////////////////////////

void Recibe_Entradas2( int Matriz[][P])

{ // Abre funcion Recibe_Entradas2_

cout << "\nAqui se reciben las entradas de la segunda matriz. " << endl;
cout << "De " << M << " filas y " << P << " columnas" << endl << endl;

for ( int i = 0; i < M; i++ )
for ( int j = 0; j < P; j++ )
{ // Abre for
cout << "Introduzca el renglon " << i + 1 << " y la columna " << j + 1 << endl;
cin >> Matriz[i][j];
} // Cierra for
} // Cierra funcion Recibe_Entradas2

//////////////////////////////////////////////////////////////////////////
// LA FUNCION MULTIPLICACION
//////////////////////////////////////////////////////////////////////////

// Esta es la funcion que multiplica. El problema, cuando se ve
// por primera vez parece dificil. La clave, en este y en otros problemas
// consiste en simplificarlo. Los casos limite de matrices son vectores.
// Traten primero de diseñar un algoritmo para multiplicar un vector
// renglon por un vector columna. Para hacer esto es necesario que los
// dos tengan la misma longitud. Esa multiplicacion les va a dar un numero
// y solo necesitan un indice para recorrer todas las entradas.
// Si quieren ahora multiplicar el mismo vector renglon por una matriz
// que incluya 2, 3 o mas columnas van a obtener 2, 3 o mas numeros
// en un renglon. Para esto necesitan dos subindices, uno para recorrer
// columnas y otro para recorrer el renglon. Finalmente, si en lugar de
// multiplicar un renglon por la matriz multiplican una matriz de n renglones
// por otra matriz, necesitaran 3 subindices.

void Multiplicacion( int Matriz1[][M], int Matriz2[][P], int Matriz3[][P])

{ // Abre la funcion Multiplicacion

for ( int k = 0; k < N; k++)
{ // abre primer ciclo for
for ( int j = 0; j < P; j++)
{ // abre el segundo ciclo for

for ( int i = 0; i < M; i++ )
Matriz3[ k ][j ] += Matriz1[k][i]*Matriz2[i][j];

} // Cierra el segundo ciclo for
}

} // Cierra la funcion Multiplicacion


///////////////////////////////////////////////////////////////////////////
// Funcion IMPRIMIR
//////////////////////////////////////////////////////////////////////////

void Imprimir( int Matriz[][P])

{ // Abre la funcion Imprimir

cout << endl << endl<< "Esta es la matriz producto: " << endl << endl;

for ( int i = 0; i < N; i++ )
{ // Abre for

for ( int j = 0; j < P; j++)

{ // abre for anidado

cout << Matriz[i][j] <<" \t";

} // Cierra for anidado

cout << endl << endl;

} // Cierra for


cout << endl << endl;
} // Cierra la funcion Imprimir


/////////////////////////////////////////////////////////////////////
// AQUI SE DEFINE LA FUNCION MAIN
////////////////////////////////////////////////////////////////////

int main()

{ // Abre la funcion main

int Matriz1[N][M] = {{0}};
int Matriz2[M][P] = {{0}};
int Matriz3[N][P] = {{0}};

Recibe_Entradas1( Matriz1 );
Recibe_Entradas2( Matriz2 );

Multiplicacion( Matriz1, Matriz2, Matriz3);
Imprimir(Matriz3);

return 0;
}