Disponible la nueva versión "donationware" 7.3 de OrganiZATOR
Descubre un nuevo concepto en el manejo de la información.
La mejor ayuda para sobrevivir en la moderna jungla de datos la tienes aquí.

Curso C++

[Home]  [Inicio]  [Índice]


4.5.5c  Estructuras de la Librería Estándar

§1  Sinopsis

Muchas funciones de las Librerías Estándar C++ utilizan estructuras como argumentos, como valores devueltos, o mediante punteros. Se trata de estructuras de formato fijo y conocido, cuya definición se encuentra en las cabeceras correspondientes.

§2  Ejemplo-1

La estructura tm definida en la cabecera <time.h>, contiene una completa descripción del tiempo cronológico en formato "de calendario";  tiene la definición siguiente:

struct tm {
  int tm_sec;   // Segundos
  int tm_min;   // Minutos
  int tm_hour;  // Horas (0--23)
  int tm_mday;  // Dia del mes (1--31)
  int tm_mon;   // Número del mes (0--11)
  int tm_year;  // Año (año de calendario menos 1900)
  int tm_wday;  // Dia de semana (0--6; Domingo = 0)
  int tm_yday;  // Dia del año (0--365)
  int tm_isdst; // Diferencia de hora por adelanto de verano
};

tm es utilizada por varias funciones estándar relacionadas con el tiempo, por ejemplo localtime, definida igalmente en <time.h>, cuyo prototipo es:

struct tm* localtime(const time_t* timer);

Como puede verse, se trata de una función que acepta como argumento un puntero a constante tipo time_t y devuelve puntero a estructura tipo tm, donde encontramos todos los datos sobre el momento señalado por timer en el formato usual de fechas: año; día del mes; de la semana; hora; minuto; segundo; etc. (al que llamaremos "Formato de Calendario").

En nuestro caso, time_t es traducida por el preprocesador como long, de modo que podemos leer el prototipo como:

struct tm* localtime(const long* timer);

Esta función devuelve un puntero a estructura tipo tm, y el manual nos indica que el argumento timer es un puntero-a-tipo time_t, que debe referenciar a un valor de tiempo (que queremos obtener en formato de "Calendario") en un formato especial; en este caso un long que contiene el tiempo en segundos desde el instante que queremos controlar, al 1 de Enero de 1970 (origen de tiempos en Unix).

Si tenemos en cuanta que la función time de Librería:

time_t time(NULL);

devuelve la hora actual del sistema (en segundos desde 1-1-1970), la hora actual en formato de "calendario" podemos obtenerla mediante:

#include <time.h>
#include <stdio.h>

int main(void) {             // ========
   struct tm* tptr;          // M1
   time_t t = time(NULL);    // M2
   tptr = localtime(&t);     // M3
   printf("hora:%3d minuto:%3d segundo:%3d\n",
          tptr->tm_hour, tptr->tm_min, tptr->tm_sec);
}

Salida:

hora:  9 minuto: 20 segundo:  4

Comentario

En M1 declaramos un puntero (tptr) a estructura tipo tm para recibir el valor devuelto por localtime en M3.

En M2 definimos un objeto t, del tipo time_t necesario para la invocación de localtime. Lo iniciamos con un valor devuelto por time. Es decir, la hora del sistema expresada en segundos desde el origen de tiempos Unix. A continuación, en M3, utilizamos un puntero a este valor para invocar la función localtime. El valor devuelto lo aplicamos al puntero declarado en M1.

Finalmente, en M4 mostramos algunos de los valores contenidos en la estructura obtenida.

§3  Ejemplo-2

En la cabecera <stdio.h> existe un typedef que traslada la palabra FILE a una estructura estándar que alberga toda la información necesaria para las controlar las operaciones de E/S de flujos (streams 5.3).

typedef struct  {
   unsigned char*  curp;       // Current active pointer
   unsigned char*  buffer;     // Data transfer buffer
   int             level;      // fill/empty level of buffer
   int             bsize;      // Buffer size
   unsigned short  istemp;     // Temporary file indicator
   unsigned short  flags;      // File status flags
   wchar_t         hold;       // Ungetc char if no buffer
   char            fd;         // File descriptor
   unsigned char   token;      // Used for validity checking
}  FILE;                        // este es el objeto FILE

de forma que cuando se encuentran unas sentencias como:

FILE* stream;
stream = fopen("PRUEBA.FIL", "w+");   // abre fichero
if (stream == NULL) {
   fprintf(stderr, "No se puede abrir el fichero.\n");
   return 1;
}

Estamos definiendo stream como puntero a una estructura FILE de diseño conocido, De forma que si la operación fopen tiene éxito, podemos referirnos a algunos detalles del fichero abierto, por ejemplo ( 4.5.4 Acceso a miembros):

cout << "Tamaño de bufer: " << stream->bsize << endl;

Nota: como puede verse, la función fopen de la Librería Estándar, que se encarga de abrir un fichero, devuelve un puntero a una estructura FILE con los datos del fichero abierto, o un puntero nulo si la operación no tiene éxito.