Mensajes

Lo de las excepciones me parece una excelente idea, pero no entiendo por qué usas "struct" en vez de "class".

Cuando todos los miembros de un objeto son públicos, uso struct en vez de class... Simple manía, no hay ninguna otra razón.

Por otro lado, meter el render dentro de la clase no me termina de convencer por la dificultad que significa procesar ese string para transformarlo en una interfaz visual. Creo que es excesivamente complicado (mucho más que usar los métodos que provee la clase Board). Quizá una buena alternativa sería crear una tercera clase que se llame Screen o algo por el estilo, donde esté el método render.

Cierto para lo visual puede ser complicado pero aún así no lo descataría... Para el modo consola sería bastante sencillo la representacion (cout<<board.ToString(); ) y tener un "mapa" en modo texto puede ser útil para una depuración en una interfaz visual.

Puedes crear un método virtual "Dibujar", que el programador herede la clase y lo implemente...

Código [Seleccionar] Expandir

[code=cpp]class Random_Number {
unsigned int seed;

public:
Random_Number();
int get(int min, int max);
};

Para que usas seed? *_*

Por otro lado:

Código (cpp) [Seleccionar] Expandir

throw "No puedes contar las minas alrededor de un punto que se encuentra fuera del tablero.";
Lanzar cadenas sueltas puede resultar complejo de capturar además pueden colisionar con las excepciones de otras clases.. Lo mejor es hacerte una clase para las excepciones:

Código (cpp) [Seleccionar] Expandir

struct Excepcion
   {

       unsigned int N_Error;
       string Mensaje;

       Excepcion(string mensaje,unsigned int Error) : Mensaje(mensaje),N_Error(Error) {};
   };


Siguiendo ese ejemplo:

Código (cpp) [Seleccionar] Expandir

throw Excepcion("No puedes contar las minas alrededor de un punto que se encuentra fuera del tablero.",FUERA_DE_RANGO);
// Fuera de rango será una constante o una macro que definas

Se pueden hacer clases que hereden de esta si quieres ser más especifico (por ejemplo, Excepcion_Minas, Excepcion_Aleatorios...).

Otra cuestión es:

Código (cpp) [Seleccionar] Expandir

void render(Board board);

Entiendo que no la has metido dentro de la clase para que sea más general. No obstante creo, que al ser una función relacionada con el tablero debería ir dentro. Para asegurarnos la independencia de cout, lo que haremos es devolver un string:

Código (cpp) [Seleccionar] Expandir

std::string Board::ToString() // Devuelve un string con la representacion del campo
{
 std::stringstream Devolver;

//Muestra el tablero
//Imprime los números de arriba (coordenadas del eje x)
Devolver<<  "     ";
for(int i = 0; i < this.get_width(); ++i) {
if(i < 9)
Devolver<<"  " << i+1;
else
Devolver<< " " << i+1;
}
Devolver<< std::endl << "     ";
for(int i = 0; i < this.get_width(); ++i)
Devolver<< "___";
Devolver<< std::endl;

//Imprime los números de la izquierda (coordenadas del eje y)
for(int y = 0; y < this.get_height(); ++y) {

if(y < 9)
Devolver << "  " << y+1 << " |";
else
Devolver<< ' ' << y+1 << " |";

//Imprimo el contenido del tablero. Es necesario que este for esté dentro del anterior.
for(int x = 0; x < this.get_width(); ++x)
if(this.square(x, y).is_hidden() ) {
if(this.square(x, y).is_marked() ) Devolver<< "  #";
else Devolver << "  *";
}
else if(board.square(x, y).get_value() == 0) Devolver << "   ";
else if(board.square(x, y).get_value() == 9)Devolver<< "  X";
else Devolver << "  " << board.square(x, y).get_value();
Devolver<< "\n\n";
}

       return Devolver.str(); // Devolvemos el string
}

El programador usuario podrá optar por mostrarlo con cout, interpetrarlo para una interfaz gráfica o bien usarlo en un archivo de depuración.

Por lo demás muy bueno y muy buen ordenado. Me gusta [/code]

[porque aún no has sobrepasado el final de archivo]

Oh, es un pequeño fallo de concepto que tiene iostream.

Veras, la bandera eof se activa cuando se accede fuera del archivo. Si tu tienes 4 preguntas, leera las 4 preguntas y hará otra vuelta más porque aún no has sobrepasado el final de archivo

Hay dos soluciones:

- La chapucera, consiste en disminuir en 1 el numero de preguntas.
- Obtener el tamaño del archivo.txt y leer dicha cantidad de bytes.

La segunda se podría implementar de la siguiente forma:

Código (cpp) [Seleccionar] Expandir

const unsigned int MAXIMO_BUFFER = 1048576; // Tamanyo máximo que podemos cargar en la RAM, he puesto aproximadamente 1 MB pero podríamos poner más

ifstream archivo;
archivo.open("preguntas.txt",ifstream::in); // Desconozco si funciona en este modo, supongo que sí
archivo.seekg(0,ios::end); // Nos vamos al final del archivo
unsigned int Tamanyo = Lectura.tellg(); // Lee la posicion actual
Lectura.seekg(0,ios::beg); // Volvemos al principio

if (Tamanyo <= MAXIMO_BUFFER)
{
    char* Buffer = new char[Tamanyo];
    archivo.read(Buffer,Tamanyo); // Leemos el archivo del tiron

    // Tenemos el archivo ya entero cargado, solo tendremos que acceder a la cadena Buffer y sacar las preguntas.

}
else // El tamanyo es excesivo, lo leeremos poco a poco
     {
        while(archivo.tellg() < tamanyo) // Mientras la posicion del archivo no llegue al tamanyo maximo
         {
     
       archivo.getline(aux, MAX_LETRAS, '>');
       archivo.getline(pregunta[nPreguntas], MAX_LETRAS, '<');
       archivo.getline(aux, MAX_LETRAS, '>');
       archivo.getline(aux, MAX_LETRAS, '>');
       archivo.getline(respuesta[nPreguntas], MAX_LETRAS, '<');
       archivo.getline(aux, MAX_LETRAS, '>');
       nPreguntas++;
        }
      }


El if es opcional, solo sería para que los archivos pequeños cargasen más rápido. Se podría dejar solo con el else.

Por cierto si usas la clase string combinada con la clase vector, podrás leer cualquier numero de preguntas con cualquier numero de letras:

Código (cpp) [Seleccionar] Expandir

#include <iostream>
#include <fstream>
#include <vector>

using namespace std;

class Pregunta{
   private:
       vector<string> preguntas;
       vector<string> respuestas;
       int nPreguntas;
   public:
       Pregunta();
       void comenzar();
       void auxMuestra();
};

Código (cpp) [Seleccionar] Expandir


        while(archivo.tellg() < tamanyo) // Mientras la posicion del archivo no llegue al tamanyo maximo
         {
      preguntas.push_back(0); // Creamos un nuevo elemento vacio en el vector
      respuestas.push_back(0);
       archivo.getline(aux, MAX_LETRAS, '>');
       archivo.getline(pregunta[nPreguntas], MAX_LETRAS, '<');
       archivo.getline(aux, MAX_LETRAS, '>');
       archivo.getline(aux, MAX_LETRAS, '>');
       archivo.getline(respuesta[nPreguntas], MAX_LETRAS, '<');
       archivo.getline(aux, MAX_LETRAS, '>');
       nPreguntas++;
        }
     


Para más información sobre las clases string y vector:
http://www.cplusplus.com/reference/string/string/
http://www.cplusplus.com/reference/vector/vector/

Puedes usar /t como si de un printf se tratase:

cout<<"/t tal y tal";

Todo correcto, no se te debería cerrar al instante *_*

Prueba a ponerlo otro cin.get() xD

Ya sé que Dev-C está obsoleto, pero con mi profesor sólo podemos usar este, que le vamos a hacer 
Por cierto, ha surgido otro problema, ahora no se me cierra al abrir el programa, pero sí se cierra cuando introduzco los números y le doy a enter.
¿A qué puede deberse?

Y como puede saber cual tienes? Le pasas el .c, el exe y tirando *_*

Pasanos el código actual, puede que no hayas puesto bien el cin.get()

[sin actualizarse]

Me he dado cuenta que mucha gente aún sigue usando el obsoleto Devcpp... Mi consejo esque os cambieis de IDE ya que:

- Lleva sin actualizarse desde el 2004.
- Su editor es muy simple, sus tabulaciones son horrorosas.
- No tiene plugins.
- No soporta varios compiladores, es más, el compilador que viene por defecto está muy obsoleto.
- La depuración no funciona, no dispone de apenas opciones de compilación...
- No es multiplataforma, solo está para Windows.

La única razón por la que alguien puede seguir con Devcpp es porque está acostumbrado a él. Pero no hay ninguna razón lógica para seguir con él (ni es más sencillo, ni es más potente, ni es más eficaz...).

Hay muchos otros IDE que harían mucho mejor su trabajo (Geany, CodeBlocks, Visual Studio...). Personalmente a mi me gusta CodeBlocks:



http://www.codeblocks.org/downloads/26

Os descargaís la versión que incluye mingw (el compilador). Lo instalais y creaís un nuevo proyecto. Terminado  

Por favor, dejad de usar IDE tan desfasados (como digo este digo Turboland).

Lo has copiado dos veces : p

Te diré una cosa sin acritud, no me gusta el estilo de programación de tu profesor/tú (Variables globales, uso de librerías innecesarias o no estándares, void main...). Muchas de esas cosas son fuentes de errores, tampoco me gusta esta función:

Código (c) [Seleccionar] Expandir

void presentacion(void)
{
char c[1];
clrscr();
printf("\n\n                      PROGRAMA POLINOMIO \n\n");
printf("          REALIZA LA SUMA, RESTA, MULTIPLICACION Y DIVISION \n\n");

}
Para dos printfs... Luego pones operaciones muy largas en el main *_*

Uso de funciones de librerías no estándares como esta:

Código (c) [Seleccionar] Expandir

clrscr();

Esto es una función exclusiva de turboland, un IDE de hace casi 8 AÑOS. Habiendo opciones que funciona en todos los IDE (como system("CLS"); ) no entiendo porque se usan funciones no estándares y además anticuadas...

Si no vais a programar en multi-archivo, iría bien ordenar las funciones por criterios lógicos. Por ejemplo, todas las funciones que devuelvan int juntas y ordenadas alfabeticamente...

Luego hay otras curiosidades como esta:

Código (c) [Seleccionar] Expandir

void insert_lista(struct apuntador **poly, float coefi, int expo)
{ //0
struct apuntador *nuevo, *aux,*ant;
int band=0;
        nuevo=(struct apuntador *) malloc (sizeof(nodo));
if(nuevo == NULL)
{//1
printf("MEMORIA AGOTADA \n");
return;
}//-1

Intenta reservar memoria, si está agotada manda un aviso y termina la función. Bien hasta ahí perfecto, el problema es que cuando llamas la función:

Código (c) [Seleccionar] Expandir

insert_lista(&polydat2,c,e);
printf("\n Desea otro termino (s/n) ? ==> ");
opcion=getche();
}  while((opcion==115) || (opcion==83));
imprime(polydat2);
pausa();

No tienes forma de saber si insert_lista termino con exito o no, si no se termino con exito debería salir del bucle y saltarse el "imprime" (incluso se podría aceptar salir del programa).

Funciones como getche() podrían sustituirse por getchar(). Así te ahorrarías incluir las conio.h que es una librería no estándar que solo funciona en Windows (pudiendo hacer el programa multiplataforma, porque hacerlo solo para Windows?).

Main debe ser int main() y debe devolver un return 0; al final:

5) void main();

Seguramente para justificar esto habría que decir que el estándar dice que void no puede ser el valor de retorno del main, lo cual es verdad, pero no siempre es suficiente. Sobretodo considerando que muchas veces en los libros el void main dice presente.

No voy a extenderme mucho con esto ya que voy a dejar los links necesarios para el que quiera entender porque sucede, pero como base comprendamos esto:

-Devolver un valor void es perder la garantia que un valor de retorno distinto de 0 implica un error, lo cual es malo tanto para el SO como para el determinado programa que pueda estar llamando a tu código.

-Esta mal acorde al estándar.

-Puede que tu programa no funcione correctamente.

Los errores pueden depender de los mecanismos de retorno o la arquitectura especifica en la cual estemos. Pero por supuesto, si elegimos un lenguaje de alto nivel como lo es C o C++, es para no tener que preocuparnos por esos asuntos.

En conclusión, el que quiera entender el " por que", leer los siguientes links.

Links:

http://www.eskimo.com/~scs/readings/voidmain.960823.html
http://home.att.net/~jackklein/ctips01.html#int_main
http://users.aber.ac.uk/auj/voidmain.shtml

Sería adecuado poner comentarios en los case para saber que opción estamos trabajando:

Código (c) [Seleccionar] Expandir

switch(seleccion_menu())
{


 case 1: // METODO DE NEWTON RAPHSON

// clrscr();
 printf("\n Metodo de Newton Raphson (RAICES) de poly1");

Tampoco se deben usar variables globales:

Código (c) [Seleccionar] Expandir

int i,caso,e;
float c,epsilon;
float coef;
int exp1,fx,x0;  // SE CAMBIA EXP SOLO AQUI O EN TODOS?
char n;
int opcion;

Primero porque permanecen todo el rato en memoria, segundo porque es una fuente de errores muy grandes... No me malinterpetres, hay usos de las variables globales legítimos pero nunca para pasar datos a funciones:
https://www.youtube.com/watch?v=0QXkRD3fzVQ

El exp1 se cambia ahí salvo que esté "enmascarado". Y con enmascarado me refiero a algo de este estilo:

Código (c) [Seleccionar] Expandir

int exp1;
...
void Funcion()
{
  int exp1; // Esta variable exp1 "enmascara" a la otra hasta que termina la funcion
}

Pasando a otra cosa. Aquí hay un error en el Switch:

Código (c) [Seleccionar] Expandir

case 7:
printf("\ Fin del Programa");
exit(0);
default:
printf("\n Operacion no valida");
//return (0);

 case 8:
fx=eval_poly(polydat1,x0);
break;

Si insertas un numero no valido se ejecutara el default... Y como no has puesto break se ejecutara también el caso 8. Lo ideal esque pongas el default al final.

Por ultimo una cosa menor:

Código (c) [Seleccionar] Expandir

xi=xi*3.1416/180;

Para ahorrarle una operación a la máquina podrías definir una constante con su valor:

Código (c) [Seleccionar] Expandir

#define Conversion 0.0174
...
xi = xi*Conversion;

Evidentemente, no te estoy echando en cara todo esto, yo era peor en tus tiempos . Pero lo de tu profesor tiene tela...

Lo del seno no lo he podido comprobar, tendría que revisar mis apuntes de mates haber como se hacia el seno de Taylor  

y si además hay "piques" sanotes más divertido aún.

Gracias amchacon!
Pero lo de Vector no lo he comprendido bien porque me sale error.
Por ejemplo, para referirnos a la primera fila habría que sustituir Vector por...?
¡Gracias por vuestra ayuda a un principiante! 

Con vector me refiero a una cosa asi:

Código (cpp) [Seleccionar] Expandir

int Numeros[10];

Numeros sería un vector.