Mensajes

muchas gracias la he estado probando esta noche y me va de lujo, es facil e intuitiva, pero ya que estamos cuando se escribe codigo no hay ninguna manera de autorreleno como en la consola o algo parecido, gracias, me has ayudado mucho

Si que hay autorelleno:



Lo que pasa esque no es tan visible. Además del autorelleno de comillas, llaves y paréntesis.

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

Instala g++ como compilador.

Después instala Codeblocks como IDE

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.

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

Código (cpp) [Seleccionar] Expandir

bool operator ==(const Matriz &a, const Matriz &b)
{
if (a.nfilas != b.nfilas or a.ncolumnas != b.ncolumnas) return false;
for (int i = 0; i < a.nfilas; ++i)
   for (int j = 0; j < a.ncolumnas; ++j)
     if (a.matr[i][j] != b.matr[i][j]) return false;

return true;
}

bool operator !=(const Matriz &a, const Matriz &b)
{
if (a.nfilas != b.nfilas or a.ncolumnas != b.ncolumnas) return true;
for (int i = 0; i < a.nfilas; ++i)
   for (int j = 0; j < a.ncolumnas; ++j)
     if (a.matr[i][j] != b.matr[i][j]) return true;

return false;
}

Esas líneas se pueden reducir a:

Código (cpp) [Seleccionar] Expandir

bool operator ==(const Matriz &a, const Matriz &b)
{
if (a.nfilas != b.nfilas or a.ncolumnas != b.ncolumnas) return false;
for (int i = 0; i < a.nfilas; ++i)
   for (int j = 0; j < a.ncolumnas; ++j)
     if (a.matr[i][j] != b.matr[i][j]) return false;

return true;
}

bool operator !=(const Matriz &a, const Matriz &b)
{
return !(a == b);
}

Te falta por añadir los determinantes (para una matriz nxn). Y los operadores *= y /= (este ultimo con números enteros).

Pues vas leyendo el archivo, cuando encuentres un <englishName>, entonces empiezas a mostrar por pantalla hasta que encuentre un <.

No sé, esque el algoritmo no tiene más. Otra cosa esque me preguntes como encontrar el <englishName>.

Pero si lo hiciera por referencias estaría modificado las matrices que estoy sumando, ¿no?

Es verdad, no había caído en eso.

Aunque solo modificarías la primera.

Voy a investigar sobre esto, parece bastante interesante. Muchas gracias ^^

EDITO: He modificado la constructora añadiendo los valores por defecto y gracias a esto he conseguido ahorrarme la constructora que tenía sin parámetros ^^ Aquí el código:

Código (cpp) [Seleccionar] Expandir


Matriz::Matriz(int filas = 0, int columnas = 0) : nfilas(filas), ncolumnas(columnas)
{
 if (nfilas > 0 and ncolumnas > 0)
 {
   matr = new int* [filas];
   for (int i = 0; i < filas; ++i)
   {
     matr[i] = new int [columnas];
   }
 }
 else matr = NULL;
}


También he modificado la constructora para que modifique los parámetros de la clase antes del propio código. Según he leído, esto sirve para inicializar objetos de otras clases usando sus constructores y no los por defecto, pero ésto no se podía hacer de otra manera también? Es decir, ¿estos dos códigos no harían lo mismo?

Código (cpp) [Seleccionar] Expandir


Clase1::Clase1(Clase2 obj) : parametro1(clase2) {}

Código (cpp) [Seleccionar] Expandir


Clase1::Clase1(Clase2 obj)
{
 parametro1 = Clase1 (obj);
}

Gracias! ^^

En realidad no me refería a eso (para eso no hace falta recurrir a C++11). Yo me refería a:

Código (cpp) [Seleccionar] Expandir

class Matriz
{
 int ** matr = NULL;
 //...
}

Como ves, lo que inicializo es el mismo atributo de la clase. Así no tengo que ponerlo en todos los constructores.

Lo hago más que nada para poder realizar operaciones del tipo:

Código [Seleccionar] Expandir

Matriz m1, m2, m3, m4;
m1 = m2 + m3 + m4;

Es decir, como si fuera un entero o cualquier otro tipo. Pero gracias por la recomendación ^^

Esa sentencia funcionaría exactamente igual con referencias, además sería muchísimo más eficiente (no tienes que estar copiando, creando nuevos objetos, borrando...).

De hecho yo me definiría y usaría el operador +=, que eso siempre va a ser más eficiente que hacer dos por separado (+ y =).

A- La contructora-copiadora que me has pasado tenia un pequeño fallo que me ha hecho pasarme, literalmente, horas a base de prueba y error hasta ver que era lo que estaba ocurriendo (que no te lo estoy echando en cara, todo lo contrario, me ha ayudado a comprender mejor el funcionamiento de POO y te estoy agradecido ^^). Al ser una constructora, había que inicializar el puntero matr a NULL porque si no, cuando hagamos la asignación dentro de la constructora, en la función borrar intentará eliminar unas posiciones de memoria que no son propias del programa, ya que la condición if (this->matr != NULL) la pasaba.

Sí bueno, yo tengo la mala suerte de atraer los errores estúpidos. Codeo demasiado rápido a veces

En C++11 puedes inicializar una variable por defecto en una clase. De formas que no tienes que estar matr = NULL en todos los constructores xD

Muchas gracias, todo arreglado.
Desconocía que no podía poner el mismo nombre al fichero que a la estructura.

Cuando hay dos variables con el mismo nombre, el compilador coge la más "interna".

La estructura al ser global, tiene menos prioridad que el FILE* (que está dentro de una función). Por tanto cada vez que llames a jugadas cogera el FILE* al ser más interna.

Lo mejor esque evites las colisiones de nombres porque llevan a confusiones, y la mejor forma de hacerlo es quitarte las variables globales de en medio.