Mensajes

¿Que IDE usas?

En el codeblocks si pulsas F8 activas el depurador, y puedes avanzando el programa línea a línea. Así ves donde el programa "estalla".

Otra opción es ir poniendo printfs por el código y ver cuantos printfs llega a escribir antes de que de error, pero el depurador es una tecnica un poco chapucera xD

* Si expones la variable directamente y después necesitas cambiarlo a función porque te das cuenta de que necesitas realizar algún chequeo u operación adicional, te ves obligado a recompilar todo el código ( en mi caso unas 6 horas ).

Un inciso.

Si cambias el tipo de la coordenada de int a float (o añades algún método/operador nuevo)... ¿No tendrías que recompilar todo el código? Para que te coja la declaración de la clase digo.

Lo pregunto por si conoces algún atajo que yo no sepa.

Simplemente es llamar continuamente a la funcion de windows api que simule "clicks".

Aunque yo lo pondria una pequeña pausa (10-20ms) entre click y click (por la cpu mas que nada).

El problema no es imprimir muchos datos, sino el acceso a pantalla. Cada vez que adcedes a pantalla el programa se "congela" hasta que se refresque.

Por eso he condensado toda tu salida en un solo string, para que haga un solo acceso a pantalla.

PD: Si crees que la diferencia de tiempo es baja, te invito a poner un simple cout en el bucle de cálculo. A ver la diferencia de tiempos

No sé porque, pero esto de los avatares me falla bastante.

Dado esta imagen:


La subo al avatar y al cambiar de página me la borra sola

Y que yo sepa las dimensiones son las legales *_*:
https://docs.google.com/document/d/1OsG_dD3SwbkOmMTg3bAFFRFY69Tq6JQLFf593n97D7Y/preview#heading=h.0f7161dd5db5

Las asignaciones de este tipo de números son muy lentas. Si puedes evitarte usar esa variable auxiliar aumentarías velocidad.

Y bueno el cout es muyyyyyyyy lento, tardarías menos en imprimir haciendo así:

Código (cpp) [Seleccionar] Expandir

#include <sstream>

//....

string valor = mpf_get_str(NULL, &buff, 10, 0, sumatoria);
stringstream aux;

for (i = 1; i < digitos * 100 + 1; i++) {
       aux << valor[i];
       if (i % 10 == 0) aux << ' ';
       if (i % 500 == 0) aux << endl;
       if (i % 50 == 0 && i < digitos * 100) aux <<endl << i + 1 << ":\t";
}
aux << endl;

cout<<aux.str();


Se puede interpretar. Pero sigue sin ser cuerdo, por ejemplo, ver "coordenada.longitud()".

Cierto.

Pues le cambio el nombre de Cord a vector y listo ^^

A mi me gusta más la tercera opción por varias razones:

* Existe encapsulamiento.

* Permite obtener un código más legible, sobretodo si se sobrecargan varios operadores ( suma, resta, ... )

* Su mantenimiento luego es más sencillo y se limitan la cantidad de "gazapos" por parte del que usa el objeto.

* Es muy sencillo acoplarle una batería te test para asegurar el correcto funcionamiento.

Se que tiene varias desventajas, pero desde mi punto de vista y mi experiencia ( trabajo en un cad orientado al sector naval ) me dicen que la tercera opción es la que más beneficios tiene.

Algunas desventajas:

* Resevas de memoria al crear copias del objeto, lo que reduce sensiblemente el rendimiento.

* Hay que currárselo todo al principio.

Vaya no lo había visto así. ¿Pero es necesario el encapsulamiento en un objeto así?

La segunda manera tambien usa un objeto, en C++ las estructuras son a todos los efectos clases con sus miembros y clases bases publicos por defecto. Los constructores no existen en C.

Muy cierto, quizás debería haber sido más preciso en la terminología ^^

Y como dato final, yo prefiero hacer vectores, no coordenadas. Aunque prácticamente son lo mismo, tienen más usos cuerdos. No es cuerdo sumar coordenadas, en cambio sí lo es sumar vectores. No es cuerdo un producto mixto de coordenadas, pero sí uno de vectores. En fin.

Las coordenadas se pueden interpretar como un vector desde la posición (0,0) a la posición (x,y). Ergo si tiene un uso cuerdo.

Quizás para no liar se puede cambiar el nombre de Cord -> Vector.

Buenas.

Frecuentemente hay que trabajar con coordenadas en la programación. Actualmente conozco tres formas de pasarlas:

1º A "pelo" con dos variables int:

Código (cpp) [Seleccionar] Expandir

int x = 1;
int y = 1;

pintar(x,y);

2º Creandote una estructura "Cord":

Código (cpp) [Seleccionar] Expandir

struct Cord
{
   int X,Y;

  Cord(int x,int y) : X(x),Y(y) {}
};

//...

pintar(Cord(1,1));

3º Un objeto Cord con su encapsulamiento y su todo:

Código (cpp) [Seleccionar] Expandir

class Cord
{
int X,Y;

public:

Cord(int x,int y) : X(x),Y(y) {}

int getX() const {return X;}
int getY() const {return Y;}
void setX(int x){X = x;}
void setY(int y){Y = y;}

bool operator==(const Cord a) const {return X == a.X && Y == a.Y;}
bool operator!=(const Cord a) const {return X != a.X || Y != a.Y;}
       Cord operator+(const Cord a) const{return Cord(A.X+X,A.Y+Y);}
};

//...

Pintar(Cord(1,1));]

En vuestra opinión. ¿Cual es la forma más adecuada? Con la primera quizás se escribe menos, aunque se te acumulan los argumentos en la función.

Al parecer ya ha editado su post con la implementación... Pero la propuesta de Ivan no es una solución eficiente (intenta mezclar 10 millones de elementos, a mí me tardó 4 minutos...).

Por cierto Leo, haciendo pruebas me he dado cuenta que hay una forma un poco más sencilla de mezclar. No es necesario definirte una constante con el numero de iteraciones:

Código (cpp) [Seleccionar] Expandir

for (int i = 0;i < v.size(); i++)
   swap(v[i],v[rand()%A.size()]);

Dicho de otra forma, recorro el array y cada posición la intercambio con otra aleatoria. De esa forma tengo la garantía de tener el array desordenado y no tengo que definir una constante "a ojo".

La función swap no es más que:

Código (cpp) [Seleccionar] Expandir

void swap(int &a,int &b)
{
   int c = a;
   a = b;
   b = c;
}