|
|
Esta sección te permite ver todos los posts escritos por este usuario. Ten en cuenta que sólo puedes ver los posts escritos en zonas a las que tienes acceso en este momento.
Mensajes - Amilius
Páginas: 1 2 3 [4] 5 6 ... 27
76
« en: Jueves 24 de Junio de 2010, 01:33 »
Como el objeto función sólo tendría que tener un parámetro para que funcione con "for_each()" podrías crear un par que contenga el par del tipo requerido por el mapa y una referencia al mapa que quieres usar.
77
« en: Sábado 19 de Junio de 2010, 03:13 »
En C++ la única diferencia entre una clase y un struct es la visibilidad de los miembros: A menos que espeficiques otra cosa en un struct todo es público y en una clase todo es privado. Tal vez sería mejor que uses las bibliotecas std, para este caso la clase vector te sirve para almacenar una lista de N elementos del tipo que quieras. Documentación (en inglés): http://www.cplusplus.com/reference/stl/vector/ #include <stdio.h> #include <vector> struct unidad { int x; int y; int w; int h; int color; int tipoUnidad; int numeroUnidad; bool movimiento; unidad() : x(600), y(400), w(10), h(10), color(6), tipoUnidad(1), numeroUnidad(1), movimiento(true) { printf("Creando unidad: 0x%pn", this); }; ~unidad() { printf("Eliminando unidad: 0x%pn", this); }; }; typedef std::vector<unidad*> Ejercito; void main() { Ejercito v; v.push_back(new unidad()); v.push_back(new unidad()); v.push_back(new unidad()); v.push_back(new unidad()); // Destruir elementos del vector Ejercito::iterator it; for (it = v.begin(); it != v.end(); it++) delete *it; unidad u; printf("Color de unidad u: %u n", u.color); }
78
« en: Lunes 17 de Mayo de 2010, 20:55 »
Tambien puedes usar el "search replace", uno que reconozca "n" y lo reemplazas por lo que necesites.
79
« en: Miércoles 17 de Marzo de 2010, 03:21 »
Efectivamente memcpy es mejor que memmove, memmove se usa cuando existe riesgo de solapamiento entre origen y destino. 
80
« en: Miércoles 17 de Marzo de 2010, 02:35 »
Tal vez un memmove? #include <string.h> . . . float S0[3][3] = {{250, 250, 0}, {500, 80, 0}, {585, 537, 0}}; float S1[3][3] = {{216, 248, 0}, {297, 146, 0}, {267, 78, 0}}; float S[3][3]; memmove(S,S0,sizeof(S)); memmove(S,S1,sizeof(S));
En todo caso usando un puntero sería mas eficiente siempre y cuando no tengas intencion de modificar los valores del arreglo.
82
« en: Jueves 26 de Noviembre de 2009, 23:07 »
Generalmente usar backgroundworkers te facilita el trabajo, pero depende de que tan "personalizado" sea el efecto que quieras lograr, si backgroundworkers te parece muy limitado para lo que quieres conseguir entonces es mejor que uses directamente hilos.
Personalmente creo que en el caso que describes es mejor tener un hilo que no dependa de ninguna ventana, que lea la fuente de datos y notifique a todas las ventanas que se "registren" a tal evento y actualizen su contenido dependiendo de la información del evento.
83
« en: Viernes 13 de Noviembre de 2009, 21:01 »
Para: -las ventas totales en el dia para cada tienda Podrias usar un arreglo de 50 elementos, un elemento por tienda. Inicializas los valores en cero y en el ciclo que revisa todas las ventas ir sumando las ventas a la tienda que corresponde. -las ventas totales para cada uno de los deportes Lo mismo, pero con arreglo de 20 elementos (uno por deporte) int totalTienda[50]; int totalDeporte[20]; for (i=0; i<max; i++){ //aca es donde necesito su orientacion para definir las dos funciones que me hacen falta para lo que necesito. sumacosart=sumacosart+venta[i].numcosart; // asumiendo que numtienda y numdepart SIEMPRE estarán en el rango correcto, sino agregar código de protección para evitar indices no válidos totalTienda[venta[i].numtienda -1]+= venta[i].numcosart; totalDeporte[venta[i].numdepart-1]+= venta[i].numcosart; }
84
« en: Miércoles 11 de Noviembre de 2009, 20:36 »
Es la forma correcta de hacerlo. Si no vas a cambiar la información apuntada tienes que definirlo de esa forma, de lo contrario das lugar a malas interpretaciones.
Si alguien que no tiene a mano la implementación y usa esa función para garantizar que esa información apuntada por col no sea modificada debería crear una copia, haciendo el código menos eficiente (y de hecho reservar y liberar memoria dinámicamente son operaciones que consumen muchísimo tiempo de CPU, comparadas con operaciones matemáticas, lógicas, control de flujo, etc). Teniendo "const char *col" le garantiza que no necesita hacer la copia por que esos datos no serán modificados.
Incluso si quisieras que el compilador te avise si por accidente estás modificando el puntero para que apunte a otro dato sería bueno que pongas
"const char * const col".
Evidentemente esto no es 100% seguro por que es posible usar casting para quitar el "const", pero lo anterior sólo se debería hacer en caso que necesitemos pasar col como parámetro a otra función que no fue bien definida pero de la que estamos seguros que no modifica los datos apuntados por col, es decir similar a la que posteaste.
85
« en: Miércoles 9 de Septiembre de 2009, 20:36 »
Si entendí bien la lista de vuelos siempre es de 7 elementos (días de la semana), como no es probable que aumenten nuevos días a la semana  entonces puedes usar un arreglo estático de punteros a "vuelos" (que debería llamarse "vuelo" por que sólo almacena un vuelo, igual "pasajeros" debería llamarse "pasajero"). Asi que inicialmente puedes tener un puntero a un arreglo estático de 7 stucts "vuelo" que puedes reservar con un solo malloc. Luego, para cada vuelo tendrías que ir agregando sus pasajeros uno a uno, con una funcion que reciba como parámetro un puntero a un struct "pasajero" ya definido y un doble puntero a un pasajero (esto para que la funcion pueda modificar el puntero en sí.) Algo mas o menos asi: agregarPasajero(pasajero* datosDelPasajero, pasajero** lugarDeAlmacenamiento) { if (NULL == (*lugarDeAlmacenamiento))) { (*lugarDeAlmacenamiento)) = datosDelPasajero; } else { agregarPasajero(datosDelPasajero, &((*lugarDeAlmacenamiento)->prox)); } }
86
« en: Domingo 6 de Septiembre de 2009, 00:56 »
Pareciera que tienes un "wild pointer", un puntero que apunta a cualquier cosa. En otras palabras parece que no reservaste memoria para tu arreglo bidimensional de nodos, o no lo inicializaste para que apunte a la dirección de memoria correcta si tu objeto red no es el que crea dichos nodos. De hecho necesitas una llamada de constructor por nodo, otra por fila de nodos y otra por columna de punteros a fila de nodos.
87
« en: Domingo 6 de Septiembre de 2009, 00:49 »
En el destructor tienes que destruir todos los objetos creados dinámicamente y liberar la memoria reservada dinámicamente por el objeto. ( Con excepción de aquellos objectos que en el momento de la destrucción no son propiedad del objecto que está siendo destruido. )
Si dejas el destructor vacío, o no defines uno, sólo serán destruidos los objetos creados en pila.
Por cierto es recomendable que te acostumbres a definir tus destructores como "virtual", a menos que no tengas pensado usar herencia.
La segunda pregunta: Por que tienes que dereferenciar el puntero asi: (*node). lo que equivale a node->
88
« en: Sábado 5 de Septiembre de 2009, 22:08 »
Tal vez el problema sea que estás tratando de usar sólo operadores de bits. Si "a" es un pixel del overlay [0..255], "b" uno del fondo [0..255] y "m" es la máscara [0..255], "c" será el resultado: c = a + (m*(b-a)/255) o bien (si es tolerable un poco de error en el cálculo): c = (a<<8 + m*(b-a)) >> 8 Nota: En procesadores Intel es mejor usar el primer caso por que los desplazamientos los hace mucho más lento en comparación a procesadores AMD. Es posible optimizar las cosas un poco usando un arreglo[511] precalculado en lugar de multiplicar y dividir todo el tiempo, quedaría asi: c = a + arreglo[255+b-a];
o bien usando punteros // Asumimos que nunca se accederá a un valor menor que -255 ni mayor que 255 int* arreglo2 = &(arreglo[255]); ... c = a + arreglo2[b-a];
Puede que la primera forma sea más rápida (siempre y cuando el arreglo sea estático) por que los compiladores suelen evitar optimizar código donde están involucrados punteros.
89
« en: Sábado 5 de Septiembre de 2009, 21:31 »
O rehaces el código par evitar usar funciones no estándar, o puedes buscar algunas bibliotecas de functiones que hagan lo mismo que conio.h pero que compilen en dev c++.
90
« en: Jueves 29 de Mayo de 2008, 22:55 »
Hola!.
Bueno, lo primero es separar la complejidad de un programa. Aqui veo tres puntos claros:
1. Manejar una lista de letras, agregando nuevas letras a la lista a medida que salen nuevas letras, anulando las que teclee el usuario o su "tiempo de vida" termine. Podrias usar un arreglo de caracteres de tamaño fijo de 256 caracteres y usarla como lista "circular", con un contador de un byte que indique la posición donde se irán agregando nuevas letras, si ya existe una letra en la posición la podrías contar como punto en contra. Si el usuario teclea una letra podrías buscar la letra en la lista desde el punto donde se insertan nuevos caracteres hacia atras y reemplazar el valor de la letra por un valor nulo como 0.
2. Mostrar al usuario la lista en pantalla de forma que parezca una lluvia de letras. En otras palabras mostrar el estado actual de la lista.
3. Tener un bucle de control un while por ejemplo que se ejecuta constantemente hasta que ocurre un evento que termine el juego. Por instancia que el usuario teclee 'ESC' o que haya dejado pasar demasiadas letras. En este bucle agregarías nuevas letras y también mostrarías el estado actual de la lista.
91
« en: Jueves 8 de Mayo de 2008, 19:17 »
Evidentemente necesitas poner código del lado del servidor de forma que pueda modificar el html. Asi que usando sólo html no lo puedes hacer.
92
« en: Miércoles 9 de Abril de 2008, 06:04 »
Pregunta:¿Cómo puedo escribir código más robusto usando punteros inteligentes? ¿Cómo puedo escribir código en C++ sin tener que preocuparme por liberar la memoria que reservé con el operador new? Respuesta: [en inglés] http://www.gotw.ca/publications/using_auto...effectively.htm
93
« en: Miércoles 9 de Abril de 2008, 05:12 »
Sería bueno que guardes en una variable lo que obtienes de getc(stdin) y compares el EOF con la variable.
¿Será que en alguna parte de tu ciclo while vuelves a leer un caracter con getc(stdin) y es por eso que necesitas 2 control+D: uno para cada getc que tienes dentro del ciclo?
94
« en: Martes 25 de Marzo de 2008, 19:59 »
La forma más rápida de empezar a programar es crearte tus propios units aparte, siguiendo la misma sintaxis de pascal, separando la lógica de interfaz de usuario de la lógica de funcionamiento del programa.
Crea un formulario para que puedas agregarle botones y campos de texto para introducir datos. Es simple y rápido crear interfaz de usuario con las herramientas del editor. Por instancia haz click en los botones y automáticamente creará la cáscara de la función donde programarás el comportamiento desencadenado al momento de apretar ese boton. Como verás existen multitud de eventos a los que puedes responder.
Ahora, dentro de esas funciones que te cree automáticamente, haz llamadas a tu código definido en los units que escribiste usando la sintaxis de pascal.
Existen algunos pequeños cambios en algunas funciones , por instancia: closeFile() en lugar de close().
Una vez que te acostumbres a programar orientado a objetos podrás comprender mejor el funcionamiento de las clases que manejan la interfaz de usuario e incluso llegará el momento que no necesites de las herramientas del IDE y podrás generar la interfaz de usuario en forma dinámica a partir de información leida de alguna base de datos.
95
« en: Martes 25 de Marzo de 2008, 19:38 »
Manuscritos es muy, pero muy dificil, toma en cuenta que hay cada tipo con cada letra que parecen garabatos de preescolar...  Cuando te encuentras con un tipo de letra manuscrito no sólo utilizas la información de la imagen, también lo que conoces de la sintaxis del lenguaje en que está escrito y el significado del texto para reconocer un conjunto coherente. Aqui tienes una breve introducción: http://cslu.cse.ogi.edu/HLTsurvey/ch2node6.htmlPara que tengas idea de la complejidad, este es un producto comercial y como puedes ver en su ejemplo muestra que puede reconocer texto escrito, pero mira que es tipo de letra imprenta y son sólo mayúsculas: http://www.irislink.com/c2-481-225/Readiri...creenshots.aspx
96
« en: Viernes 14 de Marzo de 2008, 14:52 »
En otras palabras... es que en verdad sólo almacenas un nombre.  Aqui tendrías que tener un arreglo con el número suficiente de elementos, en este caso 10: struct lab datos; // esto es para inicializar el array de estructuras
97
« en: Viernes 29 de Febrero de 2008, 20:36 »
Pues la forma más directa es cargar en memoria el archivo, leyendo linea por linea y creando una lista enlazada en "reversa". Luego mostrarlas en pantalla siguiendo el orden de la lista. Nota: Como es un archivo de texto se leen secuencialmente y se pueden leer linea por linea detectando los caracteres de saltos de linea. La función fseek no te posicionará en el archivo por lineas, sino por bytes. Y si quieres saber donde están los saltos de linea de todas formas tendrás que leer todo el archivo. Ahora o bien lees varias veces el archivo por partes para ahorrar memoria y cargar en memoria sólo una linea a la vez (por eso de mostrar el archivo en forma invertida), o lees todo el archivo de texto y lo almacenas en memoria. Lo interesante sería un algoritmo que te permita hacer esto sin tener que poner todo el archivo en memoria o tener que leer varias veces el archivo.
98
« en: Viernes 15 de Febrero de 2008, 20:45 »
Si, siempre y cuando el algoritmo de generación de números pseudo aleatorios también sea el mismo y la secuencia en que se van "pidiendo" los números a rand() también sea la misma.
99
« en: Viernes 15 de Febrero de 2008, 20:40 »
Generalmente es mejor guardar las imágenes en otra base de datos, pero sería bueno que investigues los comandos de personalización de creación de base de datos y tablas de SQL Server 2000. Según recuerdo existen opciones para organizar como se manejará la información de cada tabla y de los campos de texto gigantes. CREATE TABLE [Imagenes] ( ... ) ON [PRIMARY] TEXTIMAGE_ON [PRIMARY]
Fijate que usa [PRIMARY], asi que seguro es posible indicarle que guarde los datos de la tabla de imágenes y de textos extensos en forma separada del resto de la información o de las otras tablas, seguramente para obtener mejor rendimiento.
100
« en: Miércoles 30 de Enero de 2008, 01:36 »
¿Estas seguro que esto va asi con los @?  var LlamarDLL : TLlamarDLL; .... @LlamarDLL := GetProcAddress(DLL, 'SeleccionarValores'); if not(@LlamarDLL = nil) then
Me parece que LlamarDLL debería ser puntero a TLlamarDLL y remover las arrobas. seguramente se necesitan más cambios pero es lo que veo
Páginas: 1 2 3 [4] 5 6 ... 27
|
|
|
Mostrar Mensajes
