¿Para qué es time_t en última instancia un typedef?

Busqué en mi cuadro de Linux y vi este typedef:

typedef __time_t time_t;

Pero no pude encontrar la __time_t definición.

El artículo del artículo time_t Wikipedia arroja algo de luz sobre esto. La conclusión es que el tipo de time_tno está garantizado en la especificación C.

El time_ttipo de datos es un tipo de datos en la biblioteca ISO C definida para almacenar valores de tiempo del sistema. Dichos valores se devuelven de la time() función de biblioteca estándar . Este tipo es un typedef definido en el encabezado estándar. ISO C define time_t como un tipo aritmético, pero no especifica ningún tipo , rango, resolución o codificación en particular. Tampoco se especifican los significados de las operaciones aritméticas aplicadas a los valores de tiempo.

Los sistemas compatibles con Unix y POSIX implementan el time_ttipo como signed integer(generalmente de 32 o 64 bits de ancho) que representa el número de segundos desde el inicio de la época de Unix : medianoche UTC del 1 de enero de 1970 (sin contar los segundos bisiestos). Algunos sistemas manejan correctamente los valores de tiempo negativos, mientras que otros no. Los sistemas que utilizan un tipo de 32 bits time_tson susceptibles al problema del año 2038 .

[root]# cat time.c

#include <time.h>

int main(int argc, char** argv)
{
        time_t test;
        return 0;
}

[root]# gcc -E time.c | grep __time_t

typedef long int __time_t;

Se define a $INCDIR/bits/types.htravés de:

# 131 "/usr/include/bits/types.h" 3 4
# 1 "/usr/include/bits/typesizes.h" 1 3 4
# 132 "/usr/include/bits/types.h" 2 3 4

Normas

William Brendel citó Wikipedia, pero prefiero que salga de la boca del caballo.

El borrador estándar C99 N1256 7.23.1 / 3 "Componentes del tiempo" dice:

Los tipos declarados son size_t (descrito en 7.17) clock_t y time_t que son tipos aritméticos capaces de representar tiempos

y 6.2.5 / 18 "Tipos" dice:

Los tipos enteros y flotantes se denominan colectivamente tipos aritméticos.

POSIX 7 sys_types.h dice:

[CX] time_t será un tipo entero.

donde [CX]se define como :

[CX] Extensión al estándar ISO C.

Es una extensión porque ofrece una garantía más sólida: los puntos flotantes están fuera.

gcc one-liner

No es necesario crear un archivo como lo menciona Quassnoi :

echo | gcc -E -xc -include 'time.h' - | grep time_t

En Ubuntu 15.10 GCC 5.2, las dos líneas principales son:

typedef long int __time_t;
typedef __time_t time_t;

Desglose de comandos con algunas citas de man gcc:

• -E: "Deténgase después de la etapa de preprocesamiento; no ejecute el compilador correctamente".
• -xc: Especifique el lenguaje C, ya que la entrada proviene de stdin que no tiene extensión de archivo.
• -include file: "Procesar archivo como si" #include "archivo" "apareciera como la primera línea del archivo fuente primario".
• -: entrada de stdin

La respuesta es definitivamente específica de la implementación. Para conocer definitivamente su plataforma / compilador, simplemente agregue esta salida en algún lugar de su código:

printf ("sizeof time_t is: %d\n", sizeof(time_t));

Si la respuesta es 4 (32 bits) y sus datos deben ir más allá de 2038 , entonces tiene 25 años para migrar su código.

Sus datos estarán bien si almacena sus datos como una cadena, incluso si es algo simple como:

FILE *stream = [stream file pointer that you've opened correctly];
fprintf (stream, "%d\n", (int)time_t);

Luego, léalo de la misma manera (fread, fscanf, etc. en un int), y tendrá su tiempo de compensación de época. Una solución similar existe en .Net. Paso sin problemas números de época de 64 bits entre sistemas Win y Linux (a través de un canal de comunicaciones). Eso trae problemas de orden de bytes, pero ese es otro tema.

Para responder a la consulta de paxdiablo, diría que imprimió "19100" porque el programa se escribió de esta manera (y admito que lo hice yo mismo en los años 80):

time_t now;
struct tm local_date_time;
now = time(NULL);
// convert, then copy internal object to our object
memcpy (&local_date_time, localtime(&now), sizeof(local_date_time));
printf ("Year is: 19%02d\n", local_date_time.tm_year);

La printfdeclaración imprime la cadena fija "Año es: 19" seguida de una cadena con relleno de cero con los "años desde 1900" (definición detm->tm_year ). En 2000, ese valor es 100, obviamente. "%02d"rellena con dos ceros pero no se trunca si tiene más de dos dígitos.

La forma correcta es (cambiar a la última línea solamente):

printf ("Year is: %d\n", local_date_time.tm_year + 1900);

Nueva pregunta: ¿Cuál es la razón de ese pensamiento?

En Visual Studio 2008, el valor predeterminado es a __int64menos que usted defina _USE_32BIT_TIME_T. Es mejor fingir que no sabe cómo se define, ya que puede (y cambiará) de plataforma en plataforma.

time_tes de tipo long inten máquinas de 64 bits, de lo contrario eslong long int .

Puede verificar esto en estos archivos de encabezado:

time.h: /usr/include
types.hytypesizes.h :/usr/include/x86_64-linux-gnu/bits

(Las siguientes declaraciones no son una tras otra. Se pueden encontrar en el archivo de encabezado de respuesta usando Ctrl + f search).

1 en time.h

typedef __time_t time_t;

2) en types.h

# define __STD_TYPE     typedef  
__STD_TYPE __TIME_T_TYPE __time_t;  

3 en typesizes.h

#define __TIME_T_TYPE       __SYSCALL_SLONG_TYPE  
#if defined __x86_64__ && defined __ILP32__  
# define __SYSCALL_SLONG_TYPE   __SQUAD_TYPE  
#else
# define __SYSCALL_SLONG_TYPE   __SLONGWORD_TYPE
#endif  

4) De nuevo en types.h

#define __SLONGWORD_TYPE    long int
#if __WORDSIZE == 32
# define __SQUAD_TYPE       __quad_t
#elif __WORDSIZE == 64
# define __SQUAD_TYPE       long int  

#if __WORDSIZE == 64
typedef long int __quad_t;  
#else
__extension__ typedef long long int __quad_t;

Es un tipo entero con signo de 32 bits en la mayoría de las plataformas heredadas. Sin embargo, eso hace que su código sufra el error del año 2038 . Por lo tanto, las bibliotecas C modernas deberían definirlo como un int de 64 bits con signo, lo que es seguro durante unos miles de millones de años.

Por lo general, encontrará estos typedefs subyacentes específicos de implementación para gcc en el directorio de encabezado bitso asm. Para mí lo es /usr/include/x86_64-linux-gnu/bits/types.h.

Puede simplemente grep, o utilizar una invocación de preprocesador como la sugerida por Quassnoi para ver qué encabezado específico.

¿En qué consiste finalmente un time_t typedef?

El código robusto no le importa cuál es el tipo.

C especies time_tpara ser un tipo real como double, long long, int64_t, int, etc.

Incluso podría ser unsignedcomo los valores de retorno de muchas funciones de tiempo que indican que el error no lo es -1, pero(time_t)(-1) - Esta opción de implementación es poco común.

El punto es que la "necesidad de saber" el tipo es rara. El código debe estar escrito para evitar la necesidad.

Sin embargo, se produce una "necesidad de saber" común cuando el código quiere imprimir la materia prima time_t. La conversión al tipo entero más amplio acomodará los casos más modernos.

time_t now = 0;
time(&now);
printf("%jd", (intmax_t) now);
// or 
printf("%lld", (long long) now);

Transmitir a doubleo long doublefuncionará también, pero podría proporcionar una salida decimal inexacta

printf("%.16e", (double) now);

time_tes solo typedefpara 8 bytes ( long long/__int64) que todos los compiladores y sistemas operativos entienden. En el long intpasado , solía ser solo para (4 bytes) pero no ahora. Si nos fijamos en la time_ten la crtdefs.hque se encuentra tanto en implementaciones pero el sistema operativo va a utilizar long long.