Este sitio web usa cookies de terceros para analizar el tráfico y personalizar los anuncios. Si no está de acuerdo, abandone el sitio y no siga navegando por él. ×


10.2. Temporización

Si lo que queremos es hacer una pausa en un programa, en ocasiones tendremos funciones que nos permitan hacer una pausa de ciertas milésimas de segundo, como la función “delay” de Turbo C.

/*---------------------------*/
/*  Ejemplo en C nº 86:      */
/*  C086.C                   */
/*                           */
/*  Pausa con Turbo C        */
/*                           */
/*  Curso de C,              */
/*    Nacho Cabanes          */
/*---------------------------*/
 
#include <stdio.h>
#include <dos.h>
 
int main(){
 
    printf("Vamos a esperar 2 segundos... ");
    delay(2000);
    printf("El tiempo ha pasado.\n");
 
    return 0;
}
 

Si queremos comprobar la fecha y hora del sistema, lo podemos hacer con las funciones disponibles en “time.h”, que sí son parte del estandar ANSI C, por lo que deberían estar disponibles para casi cualquier compilador:

/*---------------------------*/
/*  Ejemplo en C nº 87:      */
/*  C087.C                   */
/*                           */
/*  Leer fecha y hora        */
/*                           */
/*  Curso de C,              */
/*    Nacho Cabanes          */
/*---------------------------*/
 
#include <stdio.h>
#include <time.h>
 
int main() {
   time_t segundos;
   struct tm *fecha;
 
   segundos = time(NULL);
 
   printf("Instante actual: %u s\n", segundos);
 
   fecha = gmtime(&segundos);
   printf("Como texto es: %s\n", asctime(fecha));
 
   printf("En concreto, la hora Greenwich es: %2d:%02d:%02d\n", 
     fecha->tm_hour, fecha->tm_min, fecha->tm_sec);
 
   return 0;
}
 

Dentro de “time.h”, tenemos definido un tipo llamado “time_t” que representará a una cierta fecha (incluyendo hora). La mayoría de los sistemas lo representan internamente como un entero largo (el número de segundos desde cierta fecha), aunque es algo que a nosotros no nos debería hacer falta saber si usamos directamente ese tipo “time_t”.

Tenemos también un tipo de registro (struct) predefinido, llamdo “struct tm”, que guarda la información desglosada del día, el mes, el año, la hora, etc. Los principales campos que contiene son éstos:

int tm_hour; /* hora (0 - 23) */
int tm_mday; /* Dia del mes (1 - 31) */
int tm_min; /* Minutos (0 - 59) */
int tm_mon; /* Mes (0 - 11 : 0 = Enero) */
int tm_sec; /* Segundos (0 - 59) */
int tm_wday; /* Dia de la semana (0 - 6 : 0 = Domingo) */
int tm_yday; /* Dia del año (0 - 365) */
int tm_year; /* Año menos 1900 */

y el modo de usarlas se ve en el fuente anterior:

printf("En concreto, la hora es: %2d:%02d:%02d\n",
fecha->tm_hour, fecha->tm_min, fecha->tm_sec);

Como hemos visto en este ejemplo, tenemos varias funciones para manipular la fecha y la hora:

* “time” devuelve el número de segundos que han pasado desde el 1 de enero de 1970. Su uso habitual es hora = time(NULL);
* “gmtime” convierte ese número de segundos que nos indica “time” a una variable de tipo “struct tm *” para que podamos conocer detalles como la hora, el minuto o el mes. En la conversión, devuelve la hora universal (UTC o GMT, hora en Greenwich), que puede no coincidir con la hora local.
* “localtime” es similar, pero devuelve la hora local, en vez de la hora universal (el sistema debe saber correctamente en qué zona horaria nos encontramos).
* “asctime” convierte un dato horario de tipo “struct tm *” a una cadena de texto que representa fecha, hora y día de la semana, siguiendo el formato Sat May 20 15:21:51 2000 (día de la semana en inglés abreviado a 3 letras, mes en inglés abreviado a 3 letras, número de día, horas, minutos, segundos, año).

Pero aún hay más:

* “difftime” calcula la diferencia entre dos fechas.
* “mktime” crea un dato de tipo “struct tm *” a partir de otro incompleto. Es útil por ejemplo para saber el día de la semana si conocemos el día, mes y año.
* …

Si queremos imitar el funcionamiento de la orden “delay” de Turbo C, lo podemos hacer leyendo continuamente la fecha y la hora, o bien usar la función “clock()”, que da una estimación (lo más aproximada que el sistema permita) del tiempo que hace que nuestro programa comenzó a ponerse en marcha:

/*---------------------------*/
/*  Ejemplo en C nº 88:      */
/*  C088.C                   */
/*                           */
/*  Pausa usando “clock”     */
/*                           */
/*  Curso de C,              */
/*    Nacho Cabanes          */
/*---------------------------*/
 
#include <stdio.h>
#include <time.h>
 
void espera (int segundos) {
  clock_t instanteFinal;
  instanteFinal = clock () + segundos * CLOCKS_PER_SEC ;
  while (clock() < instanteFinal) {}
}
 
int main () {
  int n;
  printf ("Comienza la cuenta atras...\n");
  for (n=10; n>0; n--)  {
    printf ("%d\n",n);
    espera (1);
  }
  printf ("Terminado!\n");
  return 0;
}
 

Nota: en Turbo C no existe la constante CLOCKS_PER_SEC, sino una llamada CLK_TCK con el mismo significado (“ticks” del reloj en cada segundo, para poder convertir a segundos el valor que nos indica “clock()”).