void srand(unsigned int semilla);
int rand(void);

void srand48(long int semilla);
double drand48(void);

En realidad son cuatro funciones, son análogas, srand y rand son para el manejo de enteros y srand48 y drand48 para el manejo de números reales.
La función rand genera un número aleatorio, pero si hacemos un programa que genere por ejemplo diez números aleatorios, cada vez que ejecutemos el programa vamos a obtener los mismos números, ¿por qué? Porque necesitamos definir una semilla para que en cada ejecución del programa se generen números aleatorios distintos. Pues bien, esto lo hacemos con la función srand. Hay que tener cuidado con la semilla que escogemos, puesto que si siempre escogemos la misma semilla pués la función rand generará los mismos números, por lo tanto nuestra semilla debe ser “aleatoria”, así que tomaremos como semilla la hora del sistema (también podemos tener en cuenta el pid del proceso).

Ahora veremos un ejemplo completo:

/**
*  Programa:
*      Generacion de numeros aleatorios
*  Descripcion:
*      Programa que genera numeros aleatorios en diferentes rangos
*  Archivo: alea.c
*  Ejecucion: ./alea
*  Compilar: gcc -Wall -o alea alea.c
*  Autor:
*      Jose Mato
* **/
#include <stdio.h>
#include <stdlib.h>
#include <time.h>

int main(int argc, char **argv)
{
    int num = 0;

    /* ponemos la semilla para generar numeros aleatorios, la semilla es la hora
        actual */
    srand((unsigned) time(NULL));

    /* generamos un numero aleatorio */
    num = rand();
    printf("Numero aleatorio: %d\n", num);

    /* generamos un numero aleatorio entre 0 y 9 */
    num = rand() % 10;
    printf("Numero entre 0 y 9: %d\n", num);

    /* generamos un numero aleatorio entre 1 y 10 */
    num = (rand() % 10) + 1;
    printf("Numero entre 1 y 10: %d\n", num);

    /* generamos un numero aleatorio entre 10 y 20 */
    num = (rand() % 11) + 10;
    printf("Numero entre 10 y 20: %d\n", num);

    /* semilla para numeros reales */
    srand48((unsigned) time(NULL));
    /* generamos un numero REAL entre 5 y 10 */
    float real = drand48() * (10.0 - 5.0) + 5.0;
    printf("Real entre 5 y 10: %f\n", real);

    return EXIT_SUCCESS;
}

Descargar: programa alea.c

Ya no tienes excusas para hacer programas como simulación de primitiva, quiniela de fútbol, ahorcado, …… y todo lo que se te ocurra.

No hay posts relacionados.

int sprintf(char *cadena, const char *formato, ...);

Esta función es parecida a printf, pero en vez de mandar a la salida estándar el resultado, lo almacena en la variable ‘cadena’. A continuación vamos a ver un sencillo ejemplo:

/**
 *  Programa:
 *      Conversion numero entero a cadena
 *  Descripcion:
 *      Programa que convierte un numero entero (tipo int) a una cadena de
 *      caracteres (tipo char *)
 *  Archivo: int2string.c
 *  Ejecucion: ./int2string
 *  Compilar: gcc -Wall -o int2string int2string.c
 *  Autor:
 *      Jose Mato
 * **/
#include <stdio.h>
#include <stdlib.h>

int main(int argc, char **argv)
{
    int num_entero = 529;
    char cadena[10];

    /* la salida se almacena en la variable 'cadena' -> convertimos la
       variable num_entero a un array de caracteres (string) */
    sprintf(cadena, "%d", num_entero);

    /* visualizamos la variable 'cadena' */
    puts(cadena);

    return EXIT_SUCCESS;
}

En el programa anterior vemos la transformación de un entero a una cadena, pero usando la función sprintf podemos convertir cualquier variable de tipo numérico (real, flotante, …) a una cadena, cambiando evidentemente el formato (%d, %f, %lf, …)

Descargar: programa int2string

No hay posts relacionados.

int atoi (const char *cadena)
long int strtol(const char *cadena, char *basura, int base)

Tanto atoi como strtol dada una cadena la convierten a un entero, devolviendo el número y en caso de error devuelven el número 0. A strtol hay que indicarle la base a la que queremos convertir el número, en la mayoría de los casos la base será 10.

Pero bien, tenemos que saber qué es una cadena errónea para esas funciones:

/* Cadenas validas: tanto atoi como strtol devuelven 528 */
char cad1[] = "528";
char cad2[] = "528abcdef";

/* Cadenas erroneas: tanto atoi como strtol devuelven 0 */
char cad1[] = "abcd";
char cad2[] = "abcdef528";

El problema viene en si al convertir una cadena de valor “0″ las funciones nos devolverán su valor entero ‘0′, y podemos interpretarlo como un error sin serlo. La solución dependiendo del caso sería utilizar la función strtol, que en caso de encontrar caracteres que no sean numéricos los almacenará en la variable ‘basura’, así sabremos en todo momento si la conversión fue o no exitosa.

A continuación un ejemplo de atoi y strtol que espero que os sirva de ayuda:

/**
*  Programa:
*      Conversion cadena a numero entero
*  Descripcion:
*      Programa que convierte un numero entero (tipo int) a una cadena de
*      caracteres (tipo char *)
*  Archivo: string2int.c
*  Ejecucion: ./string2int
*  Compilar: gcc -Wall -o string2int string2int.c
*  Autor:
*      Jose Mato
* **/
#include <stdio.h>
#include <stdlib.h>

int main(int argc, char **argv)
{
char cadena_valida[] = "529";
char cadena_erronea[] = "abc";
long int num = 0;
// variables para strtol
char *basura = NULL;
int base = 10;

/* forma 1: convertimos la cadena usando atoi */
num = atoi(cadena_valida);
printf("atoi (cadena valida): %ld\n", num);
num = atoi(cadena_erronea);
printf("atoi (cadena erronea): %ld\n\n", num);

/* forma 2: convertimos la cadena usando strtol */
num = strtol(cadena_valida, &amp;amp;amp;amp;basura, base);
printf("strtol (cadena valida): %ld\n", num);
num = strtol(cadena_erronea, &amp;amp;amp;amp;basura, base);
printf("strtol (cadena erronea): %ld\n", num);
if(basura[0] != 0) {
printf("Strtol ha detectado error en la cadena: %s\n", cadena_erronea);
}

return EXIT_SUCCESS;
}

Descargar: programa string2int

No hay posts relacionados.

En C un array bidimensional es un array de punteros a punteros, dónde en primer lugar tenemos que saber cuántos elementos vamos a almacenar en el array. Vamos a suponer que queremos almacenar 3 elementos al que llamaremos filas:

int filas = 3;
int **array = (int **) malloc(filas * sizeof(int *));

En el código anterior se ha declarado memoria para tres filas de números enteros, quedando así:
[0] -> “columna sin declarar”
[1] -> “columna sin declarar”
[2] -> “columna sin declarar”

Tenemos tres punteros a enteros (filas) que apuntan a “columna sin declarar”. Por lo tanto, a continuación, reservamos memoria para cada “columna sin declarar”, teniendo en cuenta que queremos que en cada fila se almacenen dos columnas de números enteros.

int columnas = 2;
int i = 0;
for(i=0; i<filas; i++) {
    array[i] = (int *) malloc(columnas * sizeof(int));
}

Ahora ya tendríamos el siguiente array:
[0] -> [0] [1]
[1] -> [0] [1]
[2] -> [0] [1]

En este momento ya podemos manejar el array dinámico como si fuese uno estático, por ejemplo:

/* inicializamos el array */
array[0][0] = 105;

/* inicializamos y visualizamos el array con un bucle for */
for(i=0; i<filas; i++) {
    for(j=0; j<columnas; j++) {
        array[i][j] = rand() % 150;
        printf("array[%d][%d] = %d  ", i, j, array[i][j]);
    }
    printf("\n");
}

Al final del programa ES ACONSEJABLE liberar la memoria del array dinámico. Esto se hace al revés de la creación del array, primero se eliman las columnas y, una vez que ya no haya columnas, se eliminan la filas, así:

/* liberamos la memoria de las columnas */
for(i=0; i<filas; i++) {
    free(array[i]);
}

/* liberamos la memoria de las filas  */
free(array);
array = NULL;

Para terminar vamos a ver el último ejemplo, este es parecido al anterior, pero en vez de trabajar con números enteros vamos a trabajar con arrays de caracteres.
El siguiente programa lo que hace es una copia de los argumentos que le pasamos al programa, visualizándolos por
pantalla y eliminado la memoria previamente reservada.

/**
*  Programa:
*      Arrays dinamicos bidimensionales
*  Descripcion:
*      Programa que hace una copia de argv para mostrar el uso de la
*      reserva dinamica de memoria en arrays bidimensionales
*  Archivo: cargv.c
*  Ejecucion: ./cargv "argumento1" "argumento 2" "argumento n"
*  Compilar: gcc -o cargv cargv.c
*  Autor:
*      Jose Mato
* **/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

int main(int argc, char **argv)
{
    int i = 0;
    int filas = 0;
    char **array = NULL;

    /* reservamos memoria para el numero de filas*/
    filas = argc;
    array = (char **) malloc(filas * sizeof(char *));

    /*  vamos recorriendo fila a fila, y para cada una reservamos
         el numero de columnas dinamicamente.
         Almacenamos el valor del argumento
    */
    for(i=0; i<filas; i++) {
        array[i] = (char *) malloc((strlen(argv[i]) + 1) * sizeof(char));
        strcpy(array[i], argv[i]);
    }

    /* mostramos los argumentos del array */
    for(i=0; i<filas; i++) {
        puts(array[i]);
    }

    /* liberamos la memoria del array en orden inverso al de creacion:
        primero las columnas y despues las filas */
    for(i=0; i<filas; i++) {
        free(array[i]);
        array[i] = NULL;
    }

    /* liberamos los punteros de las filas */
    free(array);
    array = NULL;

    return EXIT_SUCCESS;
}

Espero que os haya servido de ayuda y resolviese vuestras dudas. Y tú, ¿para qué los usaste?

Descargar: programa cargv.c

No hay posts relacionados.