elhacker.net cabecera Bienvenido(a), Visitante. Por favor Ingresar o Registrarse
¿Perdiste tu email de activación?.

 

 


Tema destacado: AIO elhacker.NET 2021 Compilación herramientas análisis y desinfección malware


+  Foro de elhacker.net
|-+  Programación
| |-+  Programación C/C++ (Moderadores: Eternal Idol, Littlehorse, K-YreX)
| | |-+  C++ - Problema con operador delete
0 Usuarios y 1 Visitante están viendo este tema.
Páginas: 1 2 [3] Ir Abajo Respuesta Imprimir
Autor Tema: C++ - Problema con operador delete  (Leído 6,333 veces)
xaps

Desconectado Desconectado

Mensajes: 157



Ver Perfil
Re: C++ - Problema con operador delete
« Respuesta #20 en: 16 Diciembre 2013, 16:56 pm »

Código
  1. bool operator ==(const Matriz &a, const Matriz &b)
  2. {
  3. if (a.nfilas != b.nfilas or a.ncolumnas != b.ncolumnas) return false;
  4. for (int i = 0; i < a.nfilas; ++i)
  5.   for (int j = 0; j < a.ncolumnas; ++j)
  6.     if (a.matr[i][j] != b.matr[i][j]) return false;
  7.  
  8. return true;
  9. }
  10.  
  11. bool operator !=(const Matriz &a, const Matriz &b)
  12. {
  13. if (a.nfilas != b.nfilas or a.ncolumnas != b.ncolumnas) return true;
  14. for (int i = 0; i < a.nfilas; ++i)
  15.   for (int j = 0; j < a.ncolumnas; ++j)
  16.     if (a.matr[i][j] != b.matr[i][j]) return true;
  17.  
  18. return false;
  19. }

Esas líneas se pueden reducir a:

Código
  1. bool operator ==(const Matriz &a, const Matriz &b)
  2. {
  3. if (a.nfilas != b.nfilas or a.ncolumnas != b.ncolumnas) return false;
  4. for (int i = 0; i < a.nfilas; ++i)
  5.   for (int j = 0; j < a.ncolumnas; ++j)
  6.     if (a.matr[i][j] != b.matr[i][j]) return false;
  7.  
  8. return true;
  9. }
  10.  
  11. bool operator !=(const Matriz &a, const Matriz &b)
  12. {
  13. return !(a == b);
  14. }
Cierto. Aún no estoy muy acostumbrado a reciclar código...  :silbar:

Te falta por añadir los determinantes (para una matriz nxn).
Para cálculo de determinantes el mejor método es Laplace, ¿verdad?

Y los operadores *= y /= (este ultimo con números enteros).
Cierto. Aunque la división no la he implementado por dos razones:
- La primera, nunca he dividido dos matrices. Supongo que no debe usarse demasiado o que no lo he necesitado de momento.
- La segunda, el hecho de que esté trabajando con enteros hace que la mayoría de divisiones sean inválidas.

Debería cambiar el tipo numérico de la matriz a float para poder realizar divisiones, ¿no? Ya que para escalonar y hacer Gauss probablemente necesite dividir según que posiciones de la matriz.


En línea

"The programmers of tomorrow are the wizards of the future" - Gave Newel
amchacon


Desconectado Desconectado

Mensajes: 1.211



Ver Perfil
Re: C++ - Problema con operador delete
« Respuesta #21 en: 16 Diciembre 2013, 17:12 pm »

Para cálculo de determinantes el mejor método es Laplace, ¿verdad?
Es el que uso yo, aunque yo detengo el algoritmo cuando es 2x2.

Cierto. Aunque la división no la he implementado por dos razones:
- La primera, nunca he dividido dos matrices. Supongo que no debe usarse demasiado o que no lo he necesitado de momento.
Dividir 2 matrices es multiplicar por su inversa.

Pero no me refería a eso sino a la división con un entero.

La segunda, el hecho de que esté trabajando con enteros hace que la mayoría de divisiones sean inválidas.
Quizás deberías plantearte hacerlo todo a double (o mejor aún, hazlo en formato plantilla y que el usuario decida).


En línea

Por favor, no me manden MP con dudas. Usen el foro, gracias.

¡Visita mi programa estrella!

Rar File Missing: Esteganografía en un Rar
xaps

Desconectado Desconectado

Mensajes: 157



Ver Perfil
Re: C++ - Problema con operador delete
« Respuesta #22 en: 16 Diciembre 2013, 17:29 pm »

Dividir 2 matrices es multiplicar por su inversa.
Cierto, no se en que estaría pensando.

Quizás deberías plantearte hacerlo todo a double (o mejor aún, hazlo en formato plantilla y que el usuario decida).
Estaba pensando en usar los templates, pero entonces tengo el problema de que a alguien se le ocurra declarar una matriz de un tipo que no sea numérico, como char o alguna clase no genérica. ¿Que se puede hacer en estos casos? He visto que se pueden hacer especializaciones, pero es imposible hacer una especialización para cada tipo de dato que considere no válido para mi matriz :S
En línea

"The programmers of tomorrow are the wizards of the future" - Gave Newel
amchacon


Desconectado Desconectado

Mensajes: 1.211



Ver Perfil
Re: C++ - Problema con operador delete
« Respuesta #23 en: 16 Diciembre 2013, 18:07 pm »

Estaba pensando en usar los templates, pero entonces tengo el problema de que a alguien se le ocurra declarar una matriz de un tipo que no sea numérico, como char
char es un dato número, es como si fuera un int de 1 byte.

o alguna clase no genérica. ¿Que se puede hacer en estos casos?
No hay ningún problema mientras la clase que use tenga definido los operadores correspondientes (+ - * / ==...).

O al menos tenga definido los operadores de las funciones que vaya a usar.
En línea

Por favor, no me manden MP con dudas. Usen el foro, gracias.

¡Visita mi programa estrella!

Rar File Missing: Esteganografía en un Rar
xaps

Desconectado Desconectado

Mensajes: 157



Ver Perfil
Re: C++ - Problema con operador delete
« Respuesta #24 en: 17 Diciembre 2013, 02:54 am »

char es un dato número, es como si fuera un int de 1 byte.
No hay ningún problema mientras la clase que use tenga definido los operadores correspondientes (+ - * / ==...).

O al menos tenga definido los operadores de las funciones que vaya a usar.
Pues me he puesto a estudiar y implementar los templates en la clase, pero me he encontrado con un problema que no me deja avanzar. La mayoría de mis sobrecargas de operadores son funciones amigas de la función, y por lo visto en general hay problemas al implementar los templates con funciones amigas. No sé si por suerte o por desgracia, la única función que parece no encajar bien con los templates es la de sobrecarga del producto. A ver si me podéis ayudar con esto, que llevo un buen rato peleándome con el error buscando, moviendo y cambiando código... Pero no lo consigo.

Vuelvo a pegar el código entero de la clase (ya que se han tenido que cambiar bastantes cosas) y el mensaje de error que estoy recibiendo:

Matriz.h:
Código
  1. #include <iostream>
  2.  
  3. using namespace std;
  4.  
  5. template <class T>
  6. class Matriz {
  7.  
  8. private:
  9.  
  10.  int nfilas;
  11.  int ncolumnas;
  12.  T **matr = NULL;
  13.  
  14.  void borrar();
  15.  
  16. public:
  17.  
  18.  //Constructora
  19.  Matriz(int filas, int columnas);
  20.  
  21.  //Constructora-copiadora
  22.  Matriz(const Matriz<T> &m);
  23.  
  24.  //Destructora
  25.  ~Matriz();
  26.  
  27.  //Consultoras
  28.  int filas() const;
  29.  int columnas() const;
  30.  T consultar(int fila, int columna) const;
  31.  
  32.  //Modificadora
  33.  void modificar(int fila, int columna, T x);
  34.  
  35.  //Operadores
  36.  Matriz& operator =(const Matriz<T> &b);
  37.  
  38.  void operator +=(const Matriz<T> &mat);
  39.  void operator -=(const Matriz<T> &mat);
  40.  
  41.  friend Matriz operator + <>(const Matriz<T> &a, const Matriz<T> &b);
  42.  friend Matriz operator - <>(const Matriz<T> &a, const Matriz<T> &b);
  43.  friend Matriz operator * <>(const Matriz<T> &a, const Matriz<T> &b);
  44.  friend Matriz operator * <>(const Matriz<T> &a, int b);
  45.  friend Matriz operator * <>(int a, const Matriz<T> &b);
  46.  
  47.  friend bool operator == <>(const Matriz<T> &a, const Matriz<T> &b);
  48.  friend bool operator != <>(const Matriz<T> &a, const Matriz<T> &b);
  49.  
  50.  friend ostream& operator << <>(ostream &salida, const Matriz<T> &mat);
  51.  friend istream& operator >> <>(istream &entrada, Matriz<T> &mat);
  52. };
  53.  
  54. template <class T>
  55. Matriz<T>::Matriz(int filas = 0, int columnas = 0) : nfilas(filas), ncolumnas(columnas)
  56. {
  57.  if (nfilas > 0 and ncolumnas > 0)
  58.  {
  59.    matr = new T* [filas];
  60.    for (int i = 0; i < filas; ++i) matr[i] = new T [columnas];
  61.  }
  62. }
  63.  
  64. template <class T>
  65. Matriz<T>::Matriz(const Matriz<T> &m) { *this = m; }
  66.  
  67. template <class T>
  68. Matriz<T>::~Matriz() { borrar(); }
  69.  
  70. template <class T>
  71. void Matriz<T>::borrar()
  72. {
  73.  if (this->matr != NULL)
  74.  {
  75.    for (int i = 0; i < nfilas; ++i) delete[] matr[i];
  76.    delete[] matr;
  77.    matr = NULL;
  78.  }
  79. }
  80.  
  81. template <class T>
  82. int Matriz<T>::filas() const { return nfilas;}
  83.  
  84. template <class T>
  85. int Matriz<T>::columnas() const { return ncolumnas;}
  86.  
  87. template <class T>
  88. T Matriz<T>::consultar(int fila, int columna) const { return matr[fila][columna];}
  89.  
  90. template <class T>
  91. void Matriz<T>::modificar(int fila, int columna, T x) { matr[fila][columna] = x;}
  92.  
  93. template <class T>
  94. Matriz<T>& Matriz<T>::operator =(const Matriz<T> &mat)
  95. {
  96.  if (this != &mat)
  97.  {
  98.    this->borrar();
  99.  
  100.    if (mat.matr)
  101.    {
  102.      this->nfilas = mat.nfilas;
  103.      this->ncolumnas = mat.ncolumnas;
  104.  
  105.      this->matr = new int* [nfilas];
  106.      for (int i = 0; i < nfilas; ++i)
  107. this->matr[i] = new int [ncolumnas];
  108.  
  109.      for (int i = 0; i < nfilas; ++i)
  110.      {
  111. for (int j = 0; j < ncolumnas; ++j)
  112.  this->matr[i][j] = mat.matr[i][j];
  113.      }
  114.    }
  115.  }
  116.  return *this;
  117. }
  118.  
  119. template <class T>
  120. void Matriz<T>::operator +=(const Matriz<T> &mat)
  121. {
  122.  if (this->nfilas != 0 and this->ncolumnas != 0 and mat.nfilas != 0 and mat.ncolumnas != 0)
  123.  {
  124.    for (int i = 0; i < nfilas; ++i)
  125.      for (int j = 0; j < ncolumnas; ++j)
  126. this->matr[i][j] += mat.matr[i][j];
  127.  }
  128. }
  129.  
  130. template <class T>
  131. void Matriz<T>::operator -=(const Matriz<T> &mat)
  132. {
  133.  if (this->nfilas != 0 and this->ncolumnas != 0 and mat.nfilas != 0 and mat.ncolumnas != 0)
  134.  {
  135.    for (int i = 0; i < nfilas; ++i)
  136.      for (int j = 0; j < ncolumnas; ++j)
  137. this->matr[i][j] -= mat.matr[i][j];
  138.  }
  139. }
  140.  
  141. template <class T>
  142. Matriz<T> operator +(const Matriz<T> &a, const Matriz<T> &b)
  143. {
  144.  int filas = a.nfilas;
  145.  int columnas = a.ncolumnas;
  146.  
  147.  Matriz<T> res(filas, columnas);
  148.  
  149.  for (int i = 0; i < filas; ++i)
  150.    for (int j = 0; j < columnas; ++j)
  151.      res.matr[i][j] = a.matr[i][j] + b.matr[i][j];
  152.  
  153.  return res;
  154. }
  155.  
  156. template <class T>
  157. Matriz<T> operator -(const Matriz<T> &a, const Matriz<T> &b)
  158. {
  159.  int filas = a.nfilas;
  160.  int columnas = a.ncolumnas;
  161.  
  162.  Matriz<T> res(filas, columnas);
  163.  
  164.  for (int i = 0; i < filas; ++i)
  165.    for (int j = 0; j < columnas; ++j)
  166.      res.matr[i][j] = a.matr[i][j] - b.matr[i][j];
  167.  
  168.  return res;
  169. }
  170.  
  171. template <class T>
  172. Matriz<T> operator *(const Matriz<T> &a, const Matriz<T> &b)
  173. {
  174.  if (a.ncolumnas == b.nfilas)
  175.  {
  176.    int pos = a.ncolumnas;
  177.  
  178.    int filas = a.nfilas;
  179.    int columnas = b.ncolumnas;
  180.  
  181.    Matriz<T> res(filas, columnas);
  182.    for (int i = 0; i < filas; ++i)
  183.    {
  184.      for (int j = 0; j < columnas; ++j)
  185.      {
  186. int value = 0;
  187. for (int k = 0; k < pos; ++k) value += a.matr[i][k] * b.matr[k][j];
  188. res.matr[i][j] = value;
  189.      }
  190.    }
  191.    return res;
  192.  }
  193. }
  194.  
  195. template <class T>
  196. Matriz<T> operator *(const Matriz<T> &a, int b)
  197. {
  198.  int filas = a.nfilas;
  199.  int columnas = a.ncolumnas;
  200.  
  201.  Matriz<T> res(filas, columnas);
  202.  for (int i = 0; i < filas; ++i)
  203.    for (int j = 0; j < columnas; ++j) res.matr[i][j] = a.matr[i][j] * b;
  204.  
  205.  return res;
  206. }
  207.  
  208. template <class T>
  209. Matriz<T> operator *(int a, const Matriz<T> &b) { return b*a; }
  210.  
  211. template <class T>
  212. bool operator ==(const Matriz<T> &a, const Matriz<T> &b)
  213. {
  214.  if (a.nfilas != b.nfilas or a.ncolumnas != b.ncolumnas) return false;
  215.  for (int i = 0; i < a.nfilas; ++i)
  216.    for (int j = 0; j < a.ncolumnas; ++j)
  217.      if (a.matr[i][j] != b.matr[i][j]) return false;
  218.  
  219.  return true;
  220. }
  221.  
  222. template <class T>
  223. bool operator !=(const Matriz<T> &a, const Matriz<T> &b) { return !(a == b); }
  224.  
  225. template <class T>
  226. ostream& operator <<(ostream &salida, const Matriz<T> &mat)
  227. {
  228.  for (int i = 0; i < mat.nfilas; ++i)
  229.  {
  230.    for (int j = 0; j < mat.ncolumnas; ++j) salida << mat.matr[i][j] << " ";
  231.    salida << endl;
  232.  }
  233.  return salida;
  234. }
  235.  
  236. template <class T>
  237. istream& operator >>(istream &entrada, Matriz<T> &mat)
  238. {
  239.  for (int i = 0; i < mat.nfilas; ++i)
  240.    for (int j = 0; j < mat.ncolumnas; ++j) entrada >> mat.matr[i][j];
  241.  return entrada;
  242. }

Y el error que recibo al compilar la clase es el siguiente:
Código:
Matriz.h:43:26: error: declaration of ‘operator*’ as non-function
Matriz.h:43:26: error: expected ‘;’ at end of member declaration
Matriz.h:43:28: error: expected unqualified-id before ‘<’ token
Matriz.h:44:26: error: declaration of ‘operator*’ as non-function
Matriz.h:44:26: error: expected ‘;’ at end of member declaration
Matriz.h:44:28: error: expected unqualified-id before ‘<’ token
Matriz.h:45:26: error: declaration of ‘operator*’ as non-function
Matriz.h:45:26: error: expected ‘;’ at end of member declaration
Matriz.h:45:28: error: expected unqualified-id before ‘<’ token

Como podéis ver he añadido "<>" al final del nombre de cada función amiga de la clase, ya que buscando solución a un problema anterior he visto que la mayoría de códigos implementaban esa metodología para las funciones amigas de la clase. Hay más información sobre ésto aquí: http://c.conclase.net/curso/?cap=040c#042_amigaplantilla
Tampoco descarto que os encontréis alguna que otra barbaridad con los templates :silbar:

Gracias por la ayuda! ^^
« Última modificación: 17 Diciembre 2013, 02:55 am por xaps » En línea

"The programmers of tomorrow are the wizards of the future" - Gave Newel
amchacon


Desconectado Desconectado

Mensajes: 1.211



Ver Perfil
Re: C++ - Problema con operador delete
« Respuesta #25 en: 17 Diciembre 2013, 19:37 pm »

La implementación no coindice con la declaración en la clase (Matriz != Matriz<T>).
En línea

Por favor, no me manden MP con dudas. Usen el foro, gracias.

¡Visita mi programa estrella!

Rar File Missing: Esteganografía en un Rar
xaps

Desconectado Desconectado

Mensajes: 157



Ver Perfil
Re: C++ - Problema con operador delete
« Respuesta #26 en: 17 Diciembre 2013, 22:11 pm »

La implementación no coindice con la declaración en la clase (Matriz != Matriz<T>).
No se a que te refieres exactamente... ¿Dices que en la declaración en la clase de las funciones amigas, he puesto Matriz en vez de Matriz<T>? Aunque lo cambie sigo teniendo el mismo problema :S
Creo que el compilador está dejando de mostrarme errores a partir de que encuentra ese, porque ayer ya estuve corrigiendo varias malas implementaciones del template y el compilador no se quejaba.  :silbar:

De todas formas, hoy le he preguntado a mi profesor de programación de la universidad sobre esto, y me ha dicho que si podía implementarlo como miembro de la clase y aplicarle la etiqueta const hasta ganaría eficiencia, ya que el compilador ya trabajaría de manera distinta que si no fuera una función constante. También me ha dicho que no desarrolla una clase y implementa sobrecargas de operadores y funciones amigas desde hace varios años, por lo que los métodos pueden haber cambiado. ¿Que opináis sobre esto?
En línea

"The programmers of tomorrow are the wizards of the future" - Gave Newel
amchacon


Desconectado Desconectado

Mensajes: 1.211



Ver Perfil
Re: C++ - Problema con operador delete
« Respuesta #27 en: 18 Diciembre 2013, 22:11 pm »

Yo lo de operadores "amigos" nunca los he usado, asi que no te puedo ayudar más en eso  :silbar:

Los de los const es bastante importante ahora que lo dices, no solo con los operadores sino con las funciones también.
En línea

Por favor, no me manden MP con dudas. Usen el foro, gracias.

¡Visita mi programa estrella!

Rar File Missing: Esteganografía en un Rar
xaps

Desconectado Desconectado

Mensajes: 157



Ver Perfil
Re: C++ - Problema con operador delete
« Respuesta #28 en: 19 Diciembre 2013, 14:15 pm »

Pues creo que voy a hacer lo que me ha dicho mi profesor, pondré las sobrecargas como miembros de la clase y aprovecharé para declararlas constantes.

En cuanto tenga una versión presentable la subo para que la veáis ^^

Gracias por la ayuda!

EDITO:

Ya he conseguido implementar la clase con templates. Os añado el código y a continuación os explico un poco que he hecho/modificado para que me funcione.

Matriz.h
Código
  1. #include <iostream>
  2.  
  3. using namespace std;
  4.  
  5. /*ostream y iostream no son templates, no entienden los cast dinámicos que se hacen con un template,
  6.  *es por esto que se necesita redefinir la clase y el método antes que el template, para convertirlo en template
  7.  *http://www.elrincondelc.com/nuevorincon/foros/viewtopic.php?t=13415&view=next&sid=02c39e45352bd867b56de65ebb1afd22
  8.  */
  9. template <class T> class Matriz;
  10. template <class T> ostream& operator <<(ostream &salida, const Matriz<T> &mat);
  11. template <class T> istream& operator >>(istream &entrada, Matriz<T> &mat);
  12. /* --- */
  13.  
  14. template <class T> class Matriz {
  15.  
  16. private:
  17.  
  18.  int nfilas;
  19.  int ncolumnas;
  20.  T **matr = NULL;
  21.  
  22.  void borrar();
  23.  
  24. public:
  25.  
  26.  //Constructora
  27.  Matriz(int filas, int columnas);
  28.  
  29.  //Constructora-copiadora
  30.  Matriz(const Matriz& m);
  31.  
  32.  //Destructora
  33.  ~Matriz();
  34.  
  35.  //Consultoras
  36.  int filas() const;
  37.  int columnas() const;
  38.  T consultar(int fila, int columna) const;
  39.  
  40.  //Modificadora
  41.  void modificar(int fila, int columna, T x);
  42.  
  43.  //Operadores
  44.  Matriz<T>& operator =(const Matriz &b);
  45.  
  46.  void operator +=(const Matriz &mat);
  47.  void operator -=(const Matriz &mat);
  48.  
  49.  Matriz<T> operator +(const Matriz &b) const;
  50.  Matriz<T> operator -(const Matriz &b) const;
  51.  Matriz<T> operator *(const Matriz &b) const;
  52.  
  53.  Matriz<T> operator *(int b) const;
  54. //Matriz<T> operator *(int a, const Matriz &b); Está declarada como pública y externa a la clase
  55.  
  56.  bool operator ==(const Matriz &b) const;
  57.  bool operator !=(const Matriz &b) const;
  58.  
  59.  friend ostream& operator << <>(ostream &salida, const Matriz<T> &mat);
  60.  friend istream& operator >> <>(istream &entrada, Matriz<T> &mat);
  61. };
  62.  
  63. template <class T>
  64. Matriz<T>::Matriz(int filas = 0, int columnas = 0) : nfilas(filas), ncolumnas(columnas)
  65. {
  66.  if (nfilas > 0 and ncolumnas > 0)
  67.  {
  68.    matr = new T* [filas];
  69.    for (int i = 0; i < filas; ++i) matr[i] = new T [columnas];
  70.  }
  71. }
  72.  
  73. template <class T>
  74. Matriz<T>::Matriz(const Matriz &m)
  75. {
  76.  *this = m;
  77. }
  78.  
  79. template <class T>
  80. Matriz<T>::~Matriz()
  81. {
  82.  borrar();
  83. }
  84.  
  85. template <class T>
  86. void Matriz<T>::borrar()
  87. {
  88.  if (this->matr != NULL)
  89.  {
  90.    for (int i = 0; i < nfilas; ++i) delete[] matr[i];
  91.    delete[] matr;
  92.    matr = NULL;
  93.  }
  94. }
  95.  
  96. template <class T>
  97. int Matriz<T>::filas() const
  98. {
  99.  return nfilas;
  100. }
  101.  
  102. template <class T>
  103. int Matriz<T>::columnas() const
  104. {
  105.  return ncolumnas;
  106. }
  107.  
  108. template <class T>
  109. T Matriz<T>::consultar(int fila, int columna) const
  110. {
  111.  return matr[fila][columna];
  112. }
  113.  
  114. template <class T>
  115. void Matriz<T>::modificar(int fila, int columna, T x)
  116. {
  117.  matr[fila][columna] = x;
  118. }
  119.  
  120. template <class T>
  121. Matriz<T>& Matriz<T>::operator =(const Matriz &mat)
  122. {
  123.  if (this != &mat)
  124.  {
  125.    this->borrar();
  126.  
  127.    if (mat.matr)
  128.    {
  129.      this->nfilas = mat.nfilas;
  130.      this->ncolumnas = mat.ncolumnas;
  131.  
  132.      this->matr = new T* [nfilas];
  133.      for (int i = 0; i < nfilas; ++i)
  134.        this->matr[i] = new T [ncolumnas];
  135.  
  136.      for (int i = 0; i < nfilas; ++i)
  137.      {
  138.        for (int j = 0; j < ncolumnas; ++j)
  139.          this->matr[i][j] = mat.matr[i][j];
  140.      }
  141.    }
  142.  }
  143.  return *this;
  144. }
  145.  
  146. template <class T>
  147. void Matriz<T>::operator +=(const Matriz &mat)
  148. {
  149.  if (this->nfilas != 0 and this->ncolumnas != 0 and mat.nfilas != 0 and mat.ncolumnas != 0)
  150.  {
  151.    for (int i = 0; i < nfilas; ++i)
  152.      for (int j = 0; j < ncolumnas; ++j)
  153.        this->matr[i][j] += mat.matr[i][j];
  154.  }
  155. }
  156.  
  157. template <class T>
  158. void Matriz<T>::operator -=(const Matriz &mat)
  159. {
  160.  if (this->nfilas != 0 and this->ncolumnas != 0 and mat.nfilas != 0 and mat.ncolumnas != 0)
  161.  {
  162.    for (int i = 0; i < nfilas; ++i)
  163.      for (int j = 0; j < ncolumnas; ++j)
  164.        this->matr[i][j] -= mat.matr[i][j];
  165.  }
  166. }
  167.  
  168. template <class T>
  169. Matriz<T> Matriz<T>::operator +(const Matriz &b) const
  170. {
  171.  int filas = this->nfilas;
  172.  int columnas = this->ncolumnas;
  173.  
  174.  Matriz<T> res(filas, columnas);
  175.  
  176.  for (int i = 0; i < filas; ++i)
  177.    for (int j = 0; j < columnas; ++j)
  178.      res.matr[i][j] = this->matr[i][j] + b.matr[i][j];
  179.  
  180.  return res;
  181. }
  182.  
  183. template <class T>
  184. Matriz<T> Matriz<T>::operator -(const Matriz &b) const
  185. {
  186.  int filas = this->nfilas;
  187.  int columnas = this->ncolumnas;
  188.  
  189.  Matriz<T> res(filas, columnas);
  190.  
  191.  for (int i = 0; i < filas; ++i)
  192.    for (int j = 0; j < columnas; ++j)
  193.      res.matr[i][j] = this->matr[i][j] - b.matr[i][j];
  194.  
  195.  return res;
  196. }
  197.  
  198. template <class T>
  199. Matriz<T> Matriz<T>::operator *(const Matriz &b) const
  200. {
  201.  if (this->ncolumnas == b.nfilas)
  202.  {
  203.    int pos = this->ncolumnas;
  204.  
  205.    int filas = this->nfilas;
  206.    int columnas = b.ncolumnas;
  207.  
  208.    Matriz<T> res(filas, columnas);
  209.    for (int i = 0; i < filas; ++i)
  210.    {
  211.      for (int j = 0; j < columnas; ++j)
  212.      {
  213.        T value = 0;
  214.        for (int k = 0; k < pos; ++k) value += this->matr[i][k] * b.matr[k][j];
  215.        res.matr[i][j] = value;
  216.      }
  217.    }
  218.    return res;
  219.  }
  220. }
  221.  
  222. template <class T>
  223. Matriz<T> Matriz<T>::operator *(int b) const
  224. {
  225.  int filas = this->nfilas;
  226.  int columnas = this->ncolumnas;
  227.  
  228.  Matriz res(filas, columnas);
  229.  for (int i = 0; i < filas; ++i)
  230.    for (int j = 0; j < columnas; ++j) res.matr[i][j] = this->matr[i][j] * b;
  231.  
  232.  return res;
  233. }
  234.  
  235. template <class T>
  236. Matriz<T> operator *(int a, const Matriz<T> &b)
  237. {
  238.  return b*a;
  239. }
  240.  
  241. template <class T>
  242. bool Matriz<T>::operator ==(const Matriz &b) const
  243. {
  244.  if (this->nfilas != b.nfilas or this->ncolumnas != b.ncolumnas) return false;
  245.  for (int i = 0; i < this->nfilas; ++i)
  246.    for (int j = 0; j < this->ncolumnas; ++j)
  247.      if (this->matr[i][j] != b.matr[i][j]) return false;
  248.  
  249.  return true;
  250. }
  251.  
  252. template <class T>
  253. bool Matriz<T>::operator !=(const Matriz<T> &b) const
  254. {
  255.  if (this->nfilas != b.nfilas or this->ncolumnas != b.ncolumnas) return true;
  256.  for (int i = 0; i < this->nfilas; ++i)
  257.    for (int j = 0; j < this->ncolumnas; ++j)
  258.      if (this->matr[i][j] != b.matr[i][j]) return true;
  259.  
  260.  return false;
  261. }
  262.  
  263. template <class T>
  264. ostream& operator <<(ostream &salida, const Matriz<T> &mat)
  265. {
  266.  for (int i = 0; i < mat.nfilas; ++i)
  267.  {
  268.    for (int j = 0; j < mat.ncolumnas; ++j) salida << mat.matr[i][j] << " ";
  269.    salida << endl;
  270.  }
  271.  return salida;
  272. }
  273.  
  274. template <class T>
  275. istream& operator >>(istream &entrada, Matriz<T> &mat)
  276. {
  277.  for (int i = 0; i < mat.nfilas; ++i)
  278.    for (int j = 0; j < mat.ncolumnas; ++j) entrada >> mat.matr[i][j];
  279.  return entrada;
  280. }

Pues bien, como podéis comprobar he arreglado el problema que tenia con las funciones friend y los templates implementando las sobrecargas como métodos de la clase y añadiendo una pre-especificación que está comentada con un enlace, dónde se explica la solución al error de las sobrecargas de iostream (parece que el problema venía por temas internos de la clase iostream que no interpretaba bien operaciones internas de los templates). La sobrecarga del operador de un entero por una matriz he tenido que declararlo como externo a la clase, ya que si se declara como método cogerá el parámetro implícito como primer parámetro de la operación.

El resto de cambios son por la implementación de los templates.

Si alguien tiene alguna duda o sugerencia, será bienvenida ^^

Saludos y gracias amchacon por toda la ayuda!

PD: Iré mejorando la clase, como ya dije quiero implementar Gauss y varias cosas más, pero de momento voy a centrarme en el estudio de punteros que para mitades de enero tengo el examen final de programación y quiero mi matricula  ;-)
« Última modificación: 19 Diciembre 2013, 16:31 pm por xaps » En línea

"The programmers of tomorrow are the wizards of the future" - Gave Newel
Páginas: 1 2 [3] Ir Arriba Respuesta Imprimir 

Ir a:  

WAP2 - Aviso Legal - Powered by SMF 1.1.21 | SMF © 2006-2008, Simple Machines