Publi

  • Por qué no debemos utilizar gets()

    19 abril, 2010 Author: Gaspar Fernández
    14 Comments

    getsA veces me sorprendo (como profesor de programación) de que en muchos sitios siguen enseñando la función gets() para la entrada de datos desde teclado sin explicar lo que puede pasar.

    gets() es una función peligrosa. Imaginemos que escribimos el siguiente programa:

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    #include <stdio.h>

    int main()
    {
      char cadena2[10];
      char cadena1[10];

      printf("c1: %x\nc2: %x\n", cadena1, cadena2);
      gets(cadena1);

      printf("Cadena 2: %s\n", cadena2);
    }

    Ahora la compilamos, ejecutamos e introducimos un texto de prueba:

    $ gcc -o test3 test3.c
    /tmp/ccK2P2ON.o: In function `main’:
    test3.c:(.text+0x32): warning: the `gets’ function is dangerous and should not be used.

    … Leer artículo completo

  • trim(), un gran amigo para eliminar caracteres en cadenas (PHP, C++, C)

    10 marzo, 2010 Author: Gaspar Fernández
    7 Comments

    A mi entender, es una de las funciones más útiles que se han inventado, como programador de PHP estoy harto de utilizarlo para filtrar información (caracteres a la derecha y a la izquierda, ya sean espacios, caracteres especiales o algún carácter que yo utilice para el control de la información).
    Sabemos que el usuario final no nos va a dejar las cosas fáciles, puesto que a veces, nos llena un campo con «intros» al principio y al final; o la información, después de pasar por HTTP, lectura de un archivo XML o por otros tratamientos, tal vez tenga un retorno de carro al final; por eso, a veces es útil hacer:

    1
    $cadena=trim($cadena);

    Pero ahora estamos en C++, bien quería postear también el código en C++, así que decidí googlear un poco para ver esto:

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    #include <string>
    const std::string whiteSpaces( " \f\n\r\t\v" );

    void trimRight( std::string& str,
          const std::string& trimChars = whiteSpaces )
    {
       std::string::size_type pos = str.
    … Leer artículo completo

  • Separar palabras de una cadena en C [ método dinámico con puntero triple ]

    4 enero, 2010 Author: Gaspar Fernández
    No comment yet

    photo-1444228250525-3d441b642d12
    Hace un mes o así publiqué un método para extraer las palabras de una cadena en un Array, ahora traigo un nuevo fragmento de código cuya misión es no estar tan limitado, y no tener que decir con antelación y con ello no tener que reservar memoria precipitadamente.

    Dejo dos códigos fuente, en el primero, la reserva de memoria para almacenaje de información es palabra por palabra, es decir, me llega una palabra reservo memoria, me llega otra, amplio en 1 elemento la memoria reservada y así hasta recibir todas (incluyo el código para probar la función):

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    #include <stdlib.h>
    #include <stdio.h>
    #include <string.h>

    /**
    ******************************************************************
    * @brief Extrae palabras de una cadena y las coloca en un puntero
    *        doble E/S (triple, por tanto).
    … Leer artículo completo

  • Cambio de base (de base b1 a b2… hasta base36 o tal vez más)

    22 mayo, 2009 Author: Gaspar Fernández
    4 Comments

    Hace tiempo tuve la necesidad de hacer una función de cambios de base, pero que no estuviera limitada, es decir, no tuviera definido qué base vamos a introducir y qué base debe devolver. Es decir, convertiremos un número en base b1 a base b2; la limitación, el número de caracteres con los que contemos, en el ejemplo hay hasta base 36, y es fácil extenderlo hasta base256… un número en hexadecimal no tiene desde el 0 al 9 y de la A a la F, pues un base36, del 0 al 9 y de la A a la Z.… Leer artículo completo

  • Volteando cadenas

    22 mayo, 2009 Author:
    5 Comments

    En C, una de las pequeñas cosas que a veces nos hace más lentos a la hora de hacer un pequeño programa es la posibilidad de darle la vuelta a una cadena. Bien, aquí traigo un pequeño código (función y ejemplo) de strrev, que además de poder dar la vuelta a una cadena, puede manipular sólo ciertos caracteres:

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    #include <stdio.h>
    #include <string.h>

    char *strrev(char *str, int strl)
    {
        /* Creamos punteros al principio y al final de la cadena */
        /*       C   A   R   A   C   T   E   R   5   \0 */
        /*       |                               |      */
        char *start = str, *end = str + strl - 1;
        char temp;
        /* Iteramos hasta que el principio y el fin coincidan */
        while(start < end)
            {
                /* Intercambiamos los caracteres */
                /* 1º  C A R A C T E R 5 */
                /* 2º  5 A R A C T E R C */
                /* 3º  5 R R A C T E A C */
                /* 4º  5 R E A C T R A C */
                /* 4º  5 R E T C A R A C */
                temp = *start;
                *start++ = *end;
                *end-- = temp;
            }
        return str;
    }

    /* Ejemplo */
    int main()
    {
        char cadena[50]="Una cadena de caracteres cualquiera";
        char tmp[50]="Una cadena de caracteres cualquiera";
        char *cad2=cadena;
        printf("Cadena original: %s\n", cadena);
        printf("Cadena al revés: %s\n", strrev(tmp, strlen(tmp)));
        strrev(cadena+14, 10);
        printf("Caracteres al revés: %s\n", cad2);
        return 0;
    }

    Esta función la encontré hace mucho tiempo navegando y me pareció muy interesante, sobre todo por cómo está hecha, creo que es de las más rápidas.… Leer artículo completo

Página anterior