A
At last I have managed to fix the error, for whoever has the same or similar and wants to see it, place here all the code and the modified parts marked.Modified code"Everything was wrong here: matrix_io.cpp(ready corrected)"template<typename E, int filas, int columnas>
std::ostream& operator<<(std::ostream& os, Matriz<E,filas,columnas>& m)
{
os << m.filas() << " " << m.columnas() << std::endl;
os << std::setprecision(4) << std::fixed;
for(int i=1; i <= m.filas(); i++)
{
for(int j=1; j <= m.columnas(); j++)
{
os << m.valor(i,j) << " ";
}
os << std::endl;
}
return os;
}
template<typename E, int F, int C>
std::istream& operator>>(std::istream& is, Matriz<E,F,C>& m)
{
int filas, columnas;
E v;
is >> filas >> columnas;
for (int i=1; i<=filas; i++)
{
for (int j=1; j<=columnas; j++)
{
is >> v;
m.asignar(i,j,v);
}
}
return is;
}
The rest of the code is practically untouched, simple mistakes.test.cpp:#include "matriz.hpp"
#define Elemento float
// Descomentar cuando implementemos la template de Matriz
#define MatrizPrueba Matriz<Elemento, 3, 3>
// Comentar cuando implementemos la template de Matriz
//#define MatrizPrueba Matriz
void probarCrearMatriz()
{
MatrizPrueba m;
std::cout << m;
}
void probarIdentidad()
{
MatrizPrueba m;
m.identidad();
std::cout << m;
}
void probarUnos()
{
MatrizPrueba m;
m.unos();
std::cout << m;
}
void probarCeros()
{
MatrizPrueba m;
m.unos();
m.ceros();
std::cout << m;
}
void probarAsignar(std::istream& is)
{
MatrizPrueba m;
int i,j;
Elemento v;
is >> i >> j >> v;
m.asignar(i, j, v);
std::cout << m;
}
void probarValor(std::istream& is)
{
MatrizPrueba m;
int i,j;
is >> i >> j;
is >> m;
std::cout << std::fixed << std::setprecision(4);
std::cout << m.valor(i,j);
}
void probarMultiplicar(std::istream& is)
{
MatrizPrueba m1, m2, m3;
is >> m1;
is >> m2;
m1.multiplicar(m2, m3);
std::cout << m3;
}
void probarSumar(std::istream& is)
{
MatrizPrueba m1, m2, m3;
is >> m1;
is >> m2;
m1.sumar(m2, m3);
std::cout << m3;
}
void probarRestar(std::istream& is)
{
MatrizPrueba m1, m2, m3;
is >> m1;
is >> m2;
m1.restar(m2, m3);
std::cout << m3;
}
void probarTrasponer(std::istream& is)
{
MatrizPrueba m1, m2;
is >> m1;
m1.trasponer(m2);
std::cout << m2;
}
Elemento cuadrado(Elemento e)
{
return e*e;
}
void probarModificar(std::istream& is)
{
MatrizPrueba m;
is >> m;
m.modificar(cuadrado);
std::cout << m;
}
void probarCopiar(std::istream& is)
{
MatrizPrueba m1, m2;
is >> m1;
is >> m2;
m1 = m2;
std::cout << m1;
}
void probarIgual(std::istream& is)
{
MatrizPrueba m1, m2;
is >> m1;
is >> m2;
if (m1 == m2)
{
std::cout << "IGUALES";
}
else
{
std::cout << "DIFERENTES";
}
}
void probarDestruir(std::istream& is)
{
MatrizPrueba m;
is >> m;
}
int main()
{
char opcion;
// Lectura de la operaci?n a probar
std::cin >> opcion;
try
{
switch(opcion)
{
case 'c': probarCrearMatriz(); break;
case 'i': probarIdentidad(); break;
case 'u': probarUnos(); break;
case 'z': probarCeros(); break;
case 'a': probarAsignar(std::cin); break;
case 'v': probarValor(std::cin); break;
case 'm': probarMultiplicar(std::cin); break;
case 'r': probarRestar(std::cin); break;
case 's': probarSumar(std::cin); break;
case 't': probarTrasponer(std::cin); break;
case 'o': probarModificar(std::cin); break;
case 'C': probarCopiar(std::cin); break;
case '=': probarIgual(std::cin); break;
case 'D': probarDestruir(std::cin); break;
}
}
catch (std::exception const& excepcion)
{
std::cout << "EXCEPCION GENERADA: " << excepcion.what() << std::endl;
}
}
matrix.cpp#include <limits>
#include <cmath>
// COMPLEJIDAD: O(F*C)
template<typename E, int F, int C>
Matriz<E,F,C>::Matriz()
{
for(int i=0; i<F; i++)
{
for(int j=0; j<C; j++)
{
elementos_[i][j] = 0; // Valor int, C++ lo convierte autom�ticamente a E.
}
}
}
template<typename E, int F, int C>
Matriz<E,F,C>::~Matriz()
{
// En este caso no tenemos memoria din�mica y no tenemos nada que hacer.
}
// COMPLEJIDAD: O(F*C)
template<typename E, int F, int C>
void Matriz<E,F,C>::identidad()
{
for(int i=0; i<F; i++)
{
for(int j=0; j<C; j++)
{
if (i==j)
{
elementos_[i][j] = 1; // Valor int, C++ lo convierte autom�ticamente a E.
}
else
{
elementos_[i][j] = 0; // Valor int, C++ lo convierte autom�ticamente a E.
}
}
}
}
template<typename E, int F, int C>
void Matriz<E,F,C>::ceros()
{
for(int i=0; i<F; i++)
{
for(int j=0; j<C; j++)
{
elementos_[i][j] = 0;
}
}
}
template<typename E, int F, int C>
E Matriz<E,F,C>::valor(int i, int j)
{
if ((i<1) || (i>F) || (j<1) || (j>C))
{
throw ECoordenadasIncorrectas();
}
else
{
return elementos_[i-1][j-1];
}
}
template<typename E, int F, int C>
void Matriz<E,F,C>::asignar(int i, int j, float v)
{
if ((i<1) || (i>F) || (j<1) || (j>C))
{
throw ECoordenadasIncorrectas();
}
else
{
elementos_[i-1][j-1] = v;
}
}
template<typename E, int F, int C>
template <typename ModificaElemento>
void Matriz<E,F,C>::modificar(ModificaElemento modifica_elemento)
{
for(int i=0; i<F; i++)
{
for(int j=0; j<C; j++)
{
elementos_[i][j] = modifica_elemento(elementos_[i][j]);
}
}
}
template<typename E, int F, int C>
Matriz<E,F,C>& Matriz<E,F,C>::operator=(Matriz<E,F,C>& m)
{
for(int i=0; i<F; i++)
{
for(int j=0; j<C; j++)
{
elementos_[i][j] = m.elementos_[i][j];
}
}
return (*this);
}
template<typename E, int F, int C>
Matriz<E,F,C>::Matriz(Matriz<E,F,C>& m)
{
(*this) = m;
}
template<typename E, int F, int C>
bool Matriz<E,F,C>::operator==(Matriz<E,F,C>& m)
{
int i = 0;
int j = 0;
bool iguales = true;
while ((i<F) && iguales)
{
j = 0;
while ((j<C) && iguales)
{
iguales = std::abs(elementos_[i][j] - m.elementos_[i][j]) < std::numeric_limits<float>::epsilon();
j++;
}
i++;
}
return iguales;
}
template<typename E, int F, int C>
bool Matriz<E,F,C>::operator!=(Matriz<E,F,C>& m)
{
return !(*this == m);
}
//EJERCICIO PARTE: IMPLEMENTACION
template<typename E, int F, int C>
void Matriz<E,F,C>::unos()
{
for(int i=0; i<F; i++)
{
for(int j=0; j<C; j++)
{
elementos_[i][j]=1;
}
}
}
template<typename E, int F, int C>
int Matriz<E,F,C>::columnas()
{
return (C);
}
template<typename E, int F, int C>
int Matriz<E,F,C>::filas()
{
return (F);
}
template<typename E, int F, int C>
void Matriz<E,F,C>::sumar(Matriz m, Matriz& salida)
{
for(int i=0; i<F; i++)
{
for(int j=0; j<C; j++)
{
salida.elementos_[i][j]=elementos_[i][j]+m.elementos_[i][j];
}
}
}
template<typename E, int F, int C>
void Matriz<E,F,C>::restar(Matriz m, Matriz& salida)
{
for(int i=0; i<F; i++)
{
for(int j=0; j<C; j++)
{
salida.elementos_[i][j]=elementos_[i][j]-m.elementos_[i][j];
}
}
}
template<typename E, int F, int C>
void Matriz<E,F,C>::multiplicar(Matriz m, Matriz& salida)
{
for(int i=0; i<F; i++)
{
for(int j=0; j<C; j++)
{
for(int k=0; k<C;k++)
{
salida.elementos_[i][j]+=elementos_[i][k]*m.elementos_[k][j];
}
}
}
}
template<typename E, int F, int C>
void Matriz<E,F,C>::trasponer(Matriz& salida)
{
for(int i=0; i<F; i++)
{
for(int j=0; j<C; j++)
{
salida.elementos_[i][j]=elementos_[j][i];
}
}
}
matrix.hpp#ifndef MATRIZ_HPP
#define MATRIZ_HPP
#include <stdexcept>
#include <iostream>
#include <iomanip>
//#define F 3
//#define C 3
template<typename E, int F, int C>
class Matriz
{
public:
// Definici�n de las clases de excepciones
class ECoordenadasIncorrectas: public std::runtime_error
{
public:
ECoordenadasIncorrectas(const std::string& w = "ECoordenadasIncorrectas"): std::runtime_error(w) {}
};
// Declaraci�n de la interfaz del TAD Matriz<E,F,C>
/**
POST: 'm' tiene todos sus elementos a cero.
COMPLEJIDAD: O(F*C)
*/
Matriz();
/** Destructor de la variable de tipo Matriz */
~Matriz();
/**
POST: Establece los valores de la matriz actual con la matriz identidad.
*/
void identidad();
void ceros();
void unos();
void multiplicar(Matriz m, Matriz& salida);
void sumar(Matriz m, Matriz& salida);
void restar(Matriz m, Matriz& salida);
void trasponer(Matriz& salida);
int filas();
int columnas();
/**
POST: 'valor(i,j)' es el elemento almacenado en la celda (i,j) de la matriz 'm'.
El rango v�lido de las coordenadas de la matriz es [1,F] y [1, C] (como en �lgebra).
EXCEPCIONES: ECoordenadasIncorrectas si 'i' o 'j' est�n fuera de rango.
*/
E valor(int i, int j);
/**
POST: valor('i','j') = 'v'
El rango v�lido de las coordenadas de la matriz es [1,F] y [1, C] (como en �lgebra).
EXCEPCIONES: ECoordenadasIncorrectas si 'i' o 'j' est�n fuera de rango.
*/
void asignar(int i, int j, float v);
/**
POST: Modifica todos los elementos de la matriz utilizando la funci�n
"float modifica_elemento(float e)" que se pasa como par�metro.
*/
template <typename ModificaElemento>
void modificar(ModificaElemento modifica_elemento);
/**
Operador de asignaci�n
NOTA IMPORTANTE:
Esta operaci�n ser� necesaria cuando la implementaci�n del TAD utilice memoria
din�mica. En este caso no ser� estrictamente necesaria dado que el operador de
asignaci�n est�ndar "=" funciona con dos variables de tipo Matriz.
En cualquier caso estaremos siempre en el lado seguro si implementamos esta operaci�n
para todo TAD.
*/
Matriz& operator=(Matriz& m);
/** Constructor de copia */
Matriz(Matriz& m);
/**
Operadores de comparaci�n
NOTA IMPORTANTE:
Esta operaci�n ser� necesaria cuando la implementaci�n del TAD utilice memoria
din�mica o cuando el == o el != est�ndar no funcione (compara byte a byte).
*/
bool operator==(Matriz& m);
bool operator!=(Matriz& m);
//EJERCICIO PARTE: ESPECIFICACION
private:
E elementos_[F][C];
};
// En las templates (TADs gen�ricos) hacemos la inclusi�n al rev�s el .cpp en el .hpp (para que
// al incluir el matrices.hpp vaya todo el c�digo y se pueda hacer la instanciaci�n de la
// template).
#include "matriz.cpp"
#include "matriz_io.cpp"
#endif // MATRIZ_HPP
Summary of error:I just had to add it. templates also a
operators overloaded matriz_io.cpp.
