Mensajes

No quiero extraer nada, pero volviendo al tema, ¿se podría inyectar una dll en el navegador y hacer que los bichos te devuelvan su posición en la pantalla?

Estás ante el mismo problema... si no eres capaz de diseñar un algoritmo que sea capaz de localizar lo que buscas en la animación... cómo esperas embutir ese código en una dll para que haga lo que tu necesitas??

No creo que nadie haya diseñado lo que tu estás buscando por lo que al final depende de tu habilidad... una vez tengas el código lo mismo te va a dar que esté en una dll o en un ejecutable.

Una estructura:

Código (c) [Seleccionar] Expandir


struct test
{
  int numero;
  char dato;
};

Puedes manejarla como información binaria pura ( no recomendado si se va a intercambiar información entre diferentes plataformas )

Código (c) [Seleccionar] Expandir


struct test estructura;

// ...

char* buffer = (char*)&estructura;

O bien puedes acceder a cada uno de sus elementos como si fuesen variables independientes:

Código (c) [Seleccionar] Expandir


struct test estructura;

estructura.numero = 7;
estructura.dato = 'A';

int numero = estructura.numero;
char dato = estructura.dato;

Si tienes una tabla en una base de datos para este ejemplo, lo normal sería que dicha tabla tuviese dos campos... uno tipo int y otro tipo char... al escribir en la base de datos, almacenas en el int el contenido de 'estructura.numero' y en el char el contenido de 'estructura.dato'... para leer de la base de datos... lo mismo, lo que tiene el campo int lo almacenas en estructura.numero y ...

Como ves nada del otro mundo.

pues a ver... tienes qSort en la stl... algoritmo de burbuja, por selección, por inserción, por mezcla, por cuentas, mediante arbol binario...

Opciones hay muchas... para más detalles de cada una mira por internet... explicar todos y cada uno de ellos puede llevar bastante tiempo.

Una de las primeras premisas que has de seguir para programar aplicaciones visuales es que la interfaz gráfica ha de funcionar toda en el mismo hilo. En caso contrario te vas a acabar encontrando con un montón de problemas sin solución.

Cuando tu programas con una interfaz gráfica... al menos si no has diseñado tu esos controles ( vamos, lo habitual ), disponen de unos mecanismos que te permiten enterarte de cuando se producen ciertos eventos.

La cantidad de eventos disponibles depende de la librería gráfica elegida... algunas disponen de multitud de eventos y otras son un poco más opacas. Sin saber qué estás empleando para hacer la interfaz gráfica es complicado darte más indicaciones. Piensa que, como he dicho, cada interfaz gráfica funciona de forma diferente y hay multitud de ellas ( WinApi, Qt, GTK, wxwidgets, MFC ... )

En el caso de WinApi, por ejemplo, a la hora de crear la aplicación tienes que indicar mediante un puntero la función que se va a encargar de gestionar los evenos de la app... en Qt funciona con signals y slots ...

Prácticamente cualquier libro de c++ que puedas conseguir que sea mínimamente reciente, es decir, que no tenga las páginas amarillas, huela a viejo o tenga fotos de ordenadores tamaño lavadora... te sirve para empezar a aprender.

Además en internet tienes infinidad de códigos, tutoriales, cursos...

Por ejemplo, el tercer hilo de este mismo foro trata precisamente sobre libros de c++.

Hay dos formas de hacer lo que dices.

La primera es la que tú has propuesto. En este caso llenas el vector de copias literales de los objetos. La segunda opción es crear objetos dinámicos y llenar el vector con punteros a las instancias.

La primera opción tiene la ventaja de que no te tienes que preocupar por la memoria, pues cuando se destruye el vector la memoria reservada por todos los objetos que contiene se libera igualmente.

Con la segunda opción tienes que borrar tu los objetos manualmente si no quieres dejar lagunas de memoria, sin embargo te aporta mucha más flexibilidad en el diseño.

Con respecto al error que comentas, te está diciendo que no has sobrecargado el constructor copia, que es el que necesita para poder hacer las copias de los objetos en el vector.

Lo que pasa, a diferencia de lo que te dice el mensaje, yo el constructor copia lo implementaría así:

Código (cpp) [Seleccionar] Expandir

Cartones( const Cartones& original );

La gracia de ponerle en '&' es que el código resultante es mucho más óptimo ya que evitas crear objetos innecesarios. Esto mismo es aplicable a 'compararCartones'.

Lo de ponerle el const es obvio, el argumento no va a sufrir cambios y es lógico, dado que es una referencia, marcarlo como constante para que quede claro que ese objeto no piensas modificarlo.

Esta misma lógica del const la puedes aplicar a todas las funciones que no modifican el estado de la clase ( se entiende por esto que no cambia absolutamente nada dentro de la clase, sus miembros, durante la ejecución de la función ):

Código (cpp) [Seleccionar] Expandir


class Cartones{
    private:
        fstream fArchivo;
        char *cNumeros;
        int iRangoInicio, iRangoFinal;
        int iCantNumeros;
        int iNumAcertadosMin, iNumAcertadosMax;
        int iNumSerie;
        int iCantNumerosAcertados;

    public:
        Cartones(int iRangoInicio, int iRangoFinal, int iCantNumeros);
        ~Cartones();
        void generarNumerosDeCarton();
        void guardarCartonAlArchivo(fstream &archivo);
        void leerCartonDesdeArchivo(fstream &archivo);
        int compararCartones( const Cartones& carton) const;

        // Getters & Setters
        void setNumSerie(int iNumSerie);
        void setCantNumerosAcertados(int iCantNumerosAcertados);
        const char* getNumeros() const;
        int getCantNumerosAcertados() const;
        int getNumSerie() const;
        int getCantNumeros() const;
};

De esta forma, si por error intentas modificar algún miembro de la clase desde dentro de una de estas funciones, el compilador te va a avisar con un error. Son mecanismos para evitar errores tontos de programación.

Además de eso... no entiendo por qué los números los almacenas en un char... creo que es mejor que uses int para ello, es un uso más natural. Y ya puestos, dado que estás en c++, casi sería más lógico que en vez de devolver un vector puro de ints ( int* ), devuelvas un vector c++ de ints ( vector< int > )... Creo que andar manejando memoria a pelo en c++ es generalmente es una mala práctica. Además haciendo esto te evitas el uso de la variable 'icantNumeros'. O incluso, para ser más coherentes con tu diseño, lo suyo sería un vector de booleanos ( vector< bool > ) y marcar con true aquellos números que hayan salido.

Realmente lo suyo sería quizás que almacenases en un pequeño vector los números que juega el cartón en vez de generar todo el cartón y marcar los números jugados... es un pequeño derroche de memoria que no te aporta nada. Usar un vector de números jugados aparte te va a simplificar el uso y gestión de la información.

Otro detalle que veo extraño es la función de compararCartones... con eso entiendo que el int indicará si los cartones son iguales o no. Para realizar esa tarea c++ dispone, en primer lugar, del tipo booleano ( bool para los amigos ). En c es muy habitual devolver un int que indique una igualdad... en c++ es más propio usar bool y que directamente retorne true o false. Además, las labores de comparación es mucho más habitual que se realicen a partir de la sobrecarga de operadores.

Un ejemplo:

Código (cpp) [Seleccionar] Expandir


class Cartones{
    public:

        // opcion fea
        int compararCartones( const Cartones& carton) const;

        // opcion ideal
        bool operator==( const Cartones& carton ) const;
        bool operator!=( const Cartones& carton ) const;
};

Además con esto consigues que el código quede más natural.

No es lo mismo poner

Código (cpp) [Seleccionar] Expandir


Cartones carton1, carton2;
// ...
if ( carton1 == carton2 )
// ...


que poner

Código (cpp) [Seleccionar] Expandir


Cartones carton1, carton2;
// ...
if ( carton1.compararCartones( carton2 ) == X ) // entiéndase X como la cantidad de numeros del carton ... segun tu implementacion ... un poco raro
// ...


Además, en la implementación de esta función modificas la clase que le pasas como parámetro... siento decirte que esos cambios son inútiles porque estás trabajando con una copia de la clase que se destruirá en cuanto salgas de esta función.

Implementaré funciones simples (que pueden dar lugar a funciones complejas) de utilización de posiciones de memoria dentro de la máquina virtual (punteros para acceder a ellas). Para especificar una posición de memoria debe utilizarse el carácter @: @1000 ' posicion de memoria 1000 (decimal).

Los procesadores más eficientes suelen tener juegos de instrucciones simples... es más sencillo, por ejemplo, programar paralelismo de instrucciones si estas son sencillas a si se eligen juegos de instrucciones complejos.

Aplicado a esto te doy la razón, la mejor solución es mantener un juego de instrucciones simple y versátil... es más sencillo de depurar, mantener y optimizar.

Por lo demás la verdad es que tiene muy buena pinta tu proyecto. Sigue así

[* Imagino que es porque no has metido el código entre las etiquetas [ code ]]

La manera que he pensado es rellenando un vector con estos 6 numeros y lo he hecho de la siguiente manera:

Entre los controles para escribir los mensajes en el foro hay un combobox que dice "GeSHi"... si lo despliegas y eliges 'c' o 'c++' ( en función de tu código ) y metes después tu código dentro de la etiqueta que te va a generar conseguirás que tu código sea más legible y fácil de leer.

El caso es que me señala en rojo la linea que esta justo debajo del while y la verdad es que no entiendo que error puede haber.¿Alguien ve este posible error?, muchas gracias y un saludo.

Te falta un punto y coma. Cuando es un bucle while normal no necesita punto y coma... cuando es un bucle do-while sí.

Además, en la línea

Código (c) [Seleccionar] Expandir

V=1+rand()%(50-1);

Tienes otro error... V tendría que ser V[ i ] * Imagino que es porque no has metido el código entre las etiquetas [ code ]

Hola, tengo que hacer el siguiente ejercicio:"Escribir una función que genere 6 números aleatorios entre 1 y 49, de la misma forma que en la primitiva.

El caso es que si lo estás haciendo en c++ puedes aprovechar también las bondades de este lenguaje para que haga por ti parte del trabajo sucio.

Me explico. Hay una clase en c++ que es 'set'. Es una lista o vector que tiene la peculiaridad de que no puede tener elementos repetidos... si adaptas un poco tu código te puedes olvidar de chequear si el número generado aleatoriamente se encuentra ya en la lista o no.

Código (cpp) [Seleccionar] Expandir


#include<stdio.h>
#include<stdlib.h>
#include<time.h>
#include <set>

void Primitiva()
{
 std::set< int > V;

 while ( V.size( ) < 6 )
 {
   V.insert( 1 + rand( ) % 49 );
 }

 // Al llegar a este punto tendrás en V seis numeros aleatorios diferentes sin repeticiones.
}

Obviamente si estás programando en c esta no es una solución viable... pero en el asunto del mensaje has puesto 'c++'

Un saludo.

hombre, filtros gráficos como tal es un campo bastante amplio.

Si buscas cosas más concretas es posible que encuentres pequeñas librerías que te proporcionen la funcionalidad... ahora que de ahí a que las librerías sean compatibles entre ellas sin hacer adaptaciones de por medio es otra cosa

Si eliges una librería más grande que cubra todas tus necesidades al menos te aseguras de que todas las funcionalidades van a ser compatibles entre sí sin tener que adaptar interfaces.

prueba con opencv