• Miércoles 8 de Diciembre de 2021, 14:29

Mostrar Mensajes

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 ... 27
1
C/C++ / Re:Contador de palabras
« en: Jueves 11 de Octubre de 2012, 02:47 »
La idea basica es contar las transiciones de "espacio blanco" a "espacio no blanco".

2
C/C++ / Re:contar palabras de una cadena de caracteres
« en: Viernes 23 de Septiembre de 2011, 22:24 »
Acabo de arreglar el fallo en el ejemplo que puse para C++.

Esta es otra forma de contar palabras, esta vez para C.
Básicamente cuenta las transiciones entre palabras y secuencias de espacios en blanco:

main.c
Código: [Seleccionar]
#include <stdio.h>

int contarPalabras(const char* cadena)
{
    int cambios = 1;
    int anteriorEsEspacio = 1;
    int actualEsEspacio;

    if (0 == cadena) return 0;

    while (*cadena)
    {
        actualEsEspacio = isspace(*cadena) != 0;
        cambios += actualEsEspacio ^ anteriorEsEspacio;
        anteriorEsEspacio = actualEsEspacio;
        cadena++;
    }

    return cambios / 2;
}

void imprimirPalabras(const char* cadena)
{
    printf("%s\nPalabras: %d\n\n", cadena, contarPalabras(cadena));
}

int main()
{
    imprimirPalabras("");
    imprimirPalabras("     ");
    imprimirPalabras("una");
    imprimirPalabras(" una");
    imprimirPalabras("una ");
    imprimirPalabras(" una ");
    imprimirPalabras(" dos palabras ");
    imprimirPalabras("dos   palabras");
    imprimirPalabras("  Varias palabras   separadas   por uno o varios espacios");
    imprimirPalabras("Varias \n Palabras\n en \n  varias  \nlineas");
}

3
C# / Re:Problema con uno de mis primeros App (nivel principante)
« en: Miércoles 10 de Agosto de 2011, 20:42 »
Hola,

El nombre de los constructores debe ser el de la clase:

Código: [Seleccionar]
    public CocheSimple()
    {
        this.Marca = "sin marca";
        this.Modelo = "Sin modelo";
        this.VelMax = 0;
    }

    public CocheSimple(string marca, string modelo, int velmax)
    {
        this.Marca = marca;
        this.Modelo = modelo;
        this.VelMax = velmax;
    }

Otro tip:

Incluye la unidad en el nombre de variables numéricas:

Código: [Seleccionar]
private int VelMaxKmH;

Cuanto menos ambiguo sea el programa mucho mejor.

4
C/C++ / Re:triangulacion de poligonos NO convexos
« en: Miércoles 3 de Agosto de 2011, 23:58 »
Simple: Todos los ángulos deben ser menores a PI, o todos mayores a PI (en caso que midas los externos)

Para medir el ángulo definido por 3 puntos:
http://es.wikipedia.org/wiki/Ley_de_cosenos


5
C# / Re:REFERECIA A OBJETO NO ESTABLECIDA COMO INSTANCIA A UN OBJETO
« en: Miércoles 3 de Agosto de 2011, 23:43 »
Me parece que esta tratando de acceder al objeto que guarda la imagen "cmd.ExecuteNonQuery()" cuando dicho objeto ya no está disponible.

Trata metiendo esto:
Código: [Seleccionar]
con.Open();
cmd.ExecuteNonQuery();


Dentro de:
Código: [Seleccionar]
using (System.IO.MemoryStream ms = new System.IO.MemoryStream())
{
...
}

6
C# / Re:un error muy simple, pero soy novato, me lo explicas? :D
« en: Miércoles 3 de Agosto de 2011, 23:33 »
Simple: El mensaje de error dice que busca "Main" pero en tu código definiste "main". Los nombres de miembros son "case sensitive".

Main != main


7
Visual C++ / Re:Convertir Cstring a char *
« en: Miércoles 27 de Julio de 2011, 02:55 »
Revisando la documentación de la clase CString de la MFC, encontré que está permitido hacer el casting: (LPCTSTR)nu
http://msdn.microsoft.com/en-us/library/awkwbzyc.aspx

Sin embargo no deberías hacer esto: (LPTSTR)nu ni esto: (TCHAR*)nu por que implica que vas a modificar los datos apuntados.

Esto debería funcionar sin necesidad de quitar el "const" al tipo apuntado.

wcstombs(aux, (LPCTSTR)nu, nu.GetLength() + 1);

Nota: asumiendo que TCHAR está definido como wchar_t y no como char.

8
Visual C++ / Re:Convertir Cstring a char *
« en: Lunes 25 de Julio de 2011, 19:02 »
Si nu es del tipo std::string entonces usa: nu.c_str(), que retorna un "const char *". Mucho ojo en el const, por que este método retorna un puntero a caracteres que no debes modificar.

9
C# / Re: Diferentes resoluciones de pantalla+como adaptar iconos
« en: Miércoles 4 de Mayo de 2011, 00:23 »
Los íconos hechos por profesionales de diseño gráfico vienen en variedad de tamaños. Muestra el que tenga tamaño adecuado.

10
C/C++ / Re: piramide n capas recursividad
« en: Lunes 25 de Abril de 2011, 20:09 »
No lo entiendes por que piensas que es complicado, pero en realidad es extremadamente simple: Sólo escribe lo que está en el enunciado:

Código: C++
  1.  
  2. unsigned int cantidadDeLadrillos(unsigned int n)
  3. {
  4.     if (n <=1) return n;
  5.     return cantidadDeLadrillos(n - 1) * 2 + 1;
  6. }
  7.  
  8.  

11
C/C++ / Re: Efiencia con punteros
« en: Jueves 14 de Abril de 2011, 18:46 »
El problema de esas pequeñas optimizaciones es que su velocidad depende mucho del contexto (las instrucciones que le preceden y suceden, el estado de la memoria, el estado del caché, etc, etc.). También depende del compilador que uses (que instrucciones genera y si está optimizado para cierto tipo de procesadores), de la arquitectura del procesador y hasta del modelo del procesador. Al final no tienes la certeza si el código será una nada más rápido o una nada más lento, a menos que midas el rendimiento varias veces con una muestra representativa del tipo de datos que serán procesados y saques un promedio para compararlos objetivamente.

Lo que si da resultados, independientes de otros factores, es reducir la complejidad matemática del algoritmo.

12
C/C++ / Re: Herencia de una clase
« en: Miércoles 30 de Marzo de 2011, 21:59 »
Revisa la implementación del constructor copia de vector, estas llenando con la segunda fila "1" en lugar de la primera "0", además estás iterando sobre filas siendo que definiste que tu vector sólo tiene una fila.
Es mejor que cambies los nombres de "n" y "m" por algo mejor como "fil" "col", o "aFil", "aCol" para evitar confusiones. Los miembros col y fil no necesitan ser públicos, pueden ser privados y tener un nombre que denote que son privados como "_col" y "_fil".

Citar
Pero no entiendo por que hay que darle esa declaración de constructor default para que luego me deje sobrecargar el copia. Me puedes decir??

Es necesario construir lo que corresponde a la clase base antes que la clase hija. Otra forma de hacerlo, sin tener que definir un constructor "by default" para matrix, es especificar en la implementación del constructor de la clase hija el constructor de la clase base que queremos usar. Por ejemplo: ": Matrix(0,0)".

13
C/C++ / Re: Herencia de una clase
« en: Miércoles 30 de Marzo de 2011, 00:05 »
Para almacenar la suma en "vector" basta sobrecargar el constructor copia de "vector" para poder recibir const matrix&. Además tienes que agregar un constructor sin párametros "default constructor" para "matrix" y también es buena idea si las clases hijas tienen uno.

Supongo que todo esto es simple ejercicio académico, por que es un poco absurdo tener esas dos clases hijas, puesto que tienen el mismo comportamiento y miembros de la clase padre.

14
C/C++ / Re: Operacion con muchos digitos
« en: Viernes 25 de Marzo de 2011, 03:40 »
No veo por ningún lado la declaración de la variable segundo.
Y es mejor usar constantes con tipo, como "24.0f".

15
C/C++ / Re: Buscar string en un archivo, y obtener datos
« en: Miércoles 23 de Marzo de 2011, 19:14 »
De acuerdo con todo, especialmente con adoptar un estilo definido de programación.

Aunque personalmente prefiero este tipo de comparaciones para verificar punteros no nulos:
Código: C++
  1.  
  2. if (ptr)
  3. {
  4. }
  5.  
  6.  

Y para los nulos prefiero usar el 0, ¿Para que escribir 4 letras y ocultar lo que en realidad es un puntero nulo?
Código: C++
  1.  
  2. if (0 == ptr)
  3. {
  4. }
  5.  
  6.  

Tampoco me hago problema con un if en una sóla linea siempre y cuando sea más rápido de leer. En casos extremadamente simples es más rápido leer esto:
Código: C++
  1.  
  2. if (0 == ptr) return;
  3.  
  4.  

que esto:
Código: C++
  1.  
  2. if (0 == ptr)
  3. {
  4.     return;
  5. }
  6.  
  7.  

16
Pascal / Re: Codigo ASCII extendido
« en: Lunes 21 de Marzo de 2011, 18:37 »
Hay varias codificaciones y tienes que poner claro cual usarás. Existen varias y no puedes diferenciar entre todas automáticamente. Por ejemplo Notepad sólo diferencia entre UTF16 y UTF8 si el archivo comienza con BOM*. Todo lo demás lo toma como ASCII extendido para windows, que es distinto del ASCII extendido para DOS. Mientras que 'á' es 160 en DOS en windows 'á' es 225.

* http://en.wikipedia.org/wiki/Byte_order_mark

17
C/C++ / Re: Instalador batch
« en: Viernes 18 de Marzo de 2011, 01:24 »
El nombre que aparece es el que está guardado en el MSI de cada parche. Lo que puedes hacer es usar ORCA para cambiar en la tabla "Property" el valor de "ProductName" en cada MSI.  El instalador de ORCA viene con el SDK de visual studio.

18
Para 3D deberían considerar usar un engine ya hecho. Existen proyectos open source de engines en source forge.

Otra alternativa interesante es el "Unreal Development Kit", que es de pago de última generación y soporta incluso iPhone y iPad. El detalle interesante es que tiene una licencia que te permite vender el juego pagando 100 $us y luego el 25% de las ganancias luego de ganar los primeros 50.000 $us.

19
C/C++ / Re: Como crear programa c++
« en: Jueves 17 de Marzo de 2011, 17:51 »
Otra forma es tomar ventaja que las salidas están secuencialmente correlacionadas a las entradas. Si conoces el código ASCII sabes que cada letra está asociada a un número: 'A' es 65, 'B' 66 y así sucesivamente para las letras del alfabeto inglés. Si c es una variable de tipo char entonces c - 64 devolverá el resultado esperado.

20
C/C++ / Re: Algoritmo para filtrar las letras mayusculas y minusculas
« en: Miércoles 16 de Marzo de 2011, 21:38 »
Código: C++
  1.  
  2. #include <string.h>
  3.  
  4. ...
  5.  
  6. if (strchr("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyzÑñÜüÁÉÍÓÚáéíóú", arr[i]))
  7.  
  8.  

21
C/C++ / Re: Pila C++
« en: Miércoles 16 de Marzo de 2011, 16:11 »
Si crees que ese código "está bien" entonces estas muy confundido en el tema de punteros. Primero tienes que desechar todo lo que crees saber de punteros y empezar desde 0.

Algunos errores:

1. No inicializaste los punteros a 0. Simplemente imperdonable.
2. Como el nombre de tipo que escogiste para "Pila" es malísimo definiste un doble puntero donde sólo era necesario un simple puntero, tal vez por accidente.
3. En lugar de pasar la dirección del puntero a push y pop, le pasas el valor apuntado. Seguro que no compila por que la función espera un doble puntero.

Deberías pasar los parámetros por referencia, una gran ventaja de C++ para mejorar la legibilidad de tu código. También puede ayudar mucho adoptar un estilo de programación para darles nombres apropiados a los tipos.


Código: C++
  1.  
  2. #include <iostream>
  3.  
  4. typedef int Valor;
  5.  
  6. struct Nodo
  7. {
  8.     Valor dato;
  9.     Nodo* abajo;
  10. };
  11.  
  12. typedef Nodo* PNodo;
  13.  
  14. bool push(PNodo& pPila, const Valor val)
  15. {
  16.     PNodo pNuevoNodo = new (std::nothrow) Nodo;
  17.     if (0 == pNuevoNodo) return false;
  18.     pNuevoNodo->abajo = pPila;
  19.     pNuevoNodo->dato = val;
  20.     pPila = pNuevoNodo;
  21.     return true;
  22. }
  23.  
  24. bool pop(PNodo& pPila, Valor& val)
  25. {
  26.     if (0 == pPila) return false;
  27.     PNodo pNodoDesechado = pPila;
  28.     pPila = pPila->abajo;
  29.     val = pNodoDesechado->dato;
  30.     delete pNodoDesechado;
  31.     return true;
  32. }
  33.  
  34. void mostrarPila(PNodo pPila)
  35. {
  36.     std::cout << "Pila:";
  37.     while (pPila)
  38.     {
  39.         std::cout << " " << pPila->dato;
  40.         pPila = pPila->abajo;
  41.     }
  42.     std::cout << std::endl;
  43. }
  44.  
  45. int main()
  46. {
  47.     PNodo pila = 0;
  48.     push(pila, 1);
  49.     mostrarPila(pila);
  50.     push(pila, 2);
  51.     mostrarPila(pila);
  52.     push(pila, 3);
  53.     mostrarPila(pila);
  54.     push(pila, 4);
  55.     mostrarPila(pila);
  56.     Valor v;
  57.     pop(pila, v);
  58.     mostrarPila(pila);
  59.     pop(pila, v);
  60.     mostrarPila(pila);
  61.     pop(pila, v);
  62.     mostrarPila(pila);
  63.     pop(pila, v);
  64.     mostrarPila(pila);
  65.     pop(pila, v);
  66.     mostrarPila(pila);
  67.  
  68.     // Pausa
  69.     char c[1];
  70.     std::cin.getline(c, 1);
  71. }
  72.  
  73.  

Esta es la versión usando clases, incluye constructor copia y operador de asignación. El operador new (std::nothrow) permite que la función push retorne falso si no existe suficiente memoria.

Código: C++
  1.  
  2. #include <iostream>
  3.  
  4. // Asi es en C++
  5.  
  6. typedef int Valor;
  7.  
  8. struct Nodo
  9. {
  10.     Valor dato;
  11.     Nodo* abajo;
  12. };
  13.  
  14. class Pila
  15. {
  16. public:
  17.     Pila() : pNodoSuperior(0) {}
  18.  
  19.     ~Pila()
  20.     {
  21.         limpiar();
  22.     }
  23.  
  24.     Pila(const Pila& p) : pNodoSuperior(0)
  25.     {
  26.         *this = p;
  27.     }
  28.  
  29.     const Pila& operator=(const Pila& p)
  30.     {
  31.         limpiar();
  32.         Nodo* pNodoActual = p.pNodoSuperior;
  33.         while (pNodoActual)
  34.         {
  35.             push(pNodoActual->dato);
  36.             pNodoActual = pNodoActual->abajo;
  37.         }
  38.         invertir();
  39.         return *this;
  40.     }
  41.  
  42.     void limpiar()
  43.     {
  44.         Nodo* pNodoTemp;
  45.         while (pNodoSuperior)
  46.         {
  47.             pNodoTemp = pNodoSuperior;
  48.             pNodoSuperior = pNodoSuperior->abajo;
  49.             delete pNodoTemp;
  50.         }
  51.     }
  52.  
  53.     bool push(const Valor& val)
  54.     {
  55.         Nodo* pNuevoNodo = new (std::nothrow) Nodo;
  56.         if (0 == pNuevoNodo) return false;
  57.         pNuevoNodo->abajo = pNodoSuperior;
  58.         pNuevoNodo->dato = val;
  59.         pNodoSuperior = pNuevoNodo;
  60.         return true;
  61.     }
  62.  
  63.     bool pop(Valor& val)
  64.     {
  65.         if (0 == pNodoSuperior) return false;
  66.         Nodo* pNodoDesechado = pNodoSuperior;
  67.         pNodoSuperior = pNodoSuperior->abajo;
  68.         val = pNodoDesechado->dato;
  69.         delete pNodoDesechado;
  70.         return true;
  71.     }
  72.  
  73.     void invertir()
  74.     {
  75.         Nodo* pNodoActual = pNodoSuperior;
  76.         Nodo* pNodoArriba = 0;
  77.         Nodo* pNodoAbajo;
  78.         while (pNodoActual)
  79.         {
  80.             pNodoAbajo = pNodoActual->abajo;
  81.             pNodoActual->abajo = pNodoArriba;
  82.             pNodoArriba = pNodoActual;
  83.             pNodoActual = pNodoAbajo;
  84.         }
  85.         pNodoSuperior = pNodoArriba;
  86.     }
  87.  
  88.     void mostrar() const
  89.     {
  90.         std::cout << "Pila: ";
  91.         Nodo* pNodoTemp = pNodoSuperior;
  92.         while (pNodoTemp)
  93.         {
  94.             std::cout << " " << pNodoTemp->dato;
  95.             pNodoTemp = pNodoTemp->abajo;
  96.         }
  97.         std::cout << std::endl;
  98.     }
  99.  
  100. private:
  101.     Nodo* pNodoSuperior;
  102.  
  103. };
  104.  
  105. int main()
  106. {
  107.     Pila p;
  108.     p.push(1);
  109.     p.mostrar();
  110.     p.push(2);
  111.     p.mostrar();
  112.     p.push(3);
  113.     p.mostrar();
  114.     p.push(4);
  115.     p.mostrar();
  116.     Valor v;
  117.    
  118.     Pila p1(p);
  119.  
  120.     p.pop(v);
  121.     p.mostrar();
  122.     p.pop(v);
  123.     p.mostrar();
  124.     p.pop(v);
  125.     p.mostrar();
  126.     p.pop(v);
  127.     p.mostrar();
  128.  
  129.     p1.mostrar();
  130.     p1.invertir();
  131.     p1.mostrar();
  132.  
  133.     // Pausa
  134.     char c[1];
  135.     std::cin.getline(c, 1);
  136. }
  137.  
  138.  

22
OpenGL / Re: redibujar
« en: Miércoles 9 de Marzo de 2011, 19:28 »
Una solución es guardar en memoria la geometría del cilindro. Por ejemplo guardando la lista de números pseudo-aleatorios generados para el cilindro. Otra forma es inicializar el generador de número pseudo-aleatorios siempre con la misma semilla justo antes de pedirle números para definir la geometría del cilindro. La última opción te permitiría dibujar miles de cilindros de formas ligeramente distintas sin necesidad de guardar en memoria las pequeñas variaciones en su geometría.

23
C/C++ / Re: contar palabras de una cadena de caracteres
« en: Viernes 4 de Marzo de 2011, 19:43 »
Cita de: "m0skit0"
Con char* también estás reservando y liberando memoria.

"char*" es sólo un puntero, no implica reservar ni liberar memoria. El ejemplo que puse tampoco reserva ni libera memoria directamente por que es la clase std::string la que reserva y libera la cantidad de memoria necesaria.

Cita de: "m0skit0"
Mezclar C y C++ para un ejemplo pequeño no hay problema. Mezcla C y C++ en un proyecto grande y luego venid llorando.

Para nada, nunca he tenido ese problema. Lo que si es problema es que los programadores digan que saben C++ cuando no tienen idea de POO, o cuando dicen que saben C y creen que la memoria se libera mágicamente o te llenan el código de posibles "buffer overflow". O cuando no se toman el tiempo suficiente para leer la documentación de las bibliotecas que van a usar y te llenan el código de "leaks". También están los que no pueden vivir sin abusar de los patrones de diseño y para colmo los implementan mal. Etc, etc, etc. Pero mezclar C con C++ nunca ha sido problema.  :mellow:

24
C/C++ / Re: Duda punteros!
« en: Miércoles 2 de Marzo de 2011, 04:56 »
Es un alias, introducido en C++ para mayor comodidad al momento de pasar y usar parámetros por referencia:
Pasa y usa el parámetro como si fuera del tipo "tconces".

25
C/C++ / Re: contar palabras de una cadena de caracteres
« en: Miércoles 2 de Marzo de 2011, 04:43 »
Bueno estas son las ventajas de usar const char* :

1. Es mucho más rápido que usar el operador[] de std::string. (Usando un desensamblador (rodeando el código con instrucciones asm que nunca encontrarías en un programa normal ) es posible ubicar el código generado y tener una buena idea de la diferencia.)
2. No tienes que crear una instancia de std::string para llamar a esa función. Es decir si no tenías un objeto std::string de antemano. Reservar y liberar memoria para una instancia temporal es mucho castigo para la eficiencia de cualquier aplicación.
3. No tienes que incluir <string>, como ya dijeron no es necesario conocer esa clase para poder entender el código.

No es que tenga algo en contra de std::string, todo lo contrario, por que detesto reservar y liberar memoria en C todo el tiempo hasta para una simple cadena. Pero si tengo chance de tomar lo mejor de c++ y c, pues lo hago.

Páginas: [1] 2 3 ... 27