difftime, _difftime32, _difftime64

Recherche la différence entre deux heures.

Syntaxe

double difftime( time_t timeEnd, time_t timeStart );
double _difftime32( __time32_t timeEnd, __time32_t timeStart );
double _difftime64( __time64_t timeEnd, __time64_t timeStart );

Paramètres

timeEnd
Heure de fin

timeStart
Heure de début

Valeur retournée

difftime retourne le temps écoulé en secondes, entre timeStart et timeEnd. La valeur retournée est un nombre à virgule flottante double précision. Cette valeur peut être 0, indiquant alors une erreur.

Notes

La fonction difftime calcule la différence entre les deux valeurs de temps timeStart et timeEnd fournies.

La valeur de temps fournie doit appartenir à la plage time_t. time_t est une valeur 64 bits. Ainsi, la fin de la plage a été repoussée du 18 janvier 2038 à 23:59:59, heure UTC au 31 décembre 3000 à 23:59:59. Le début de la plage de time_t est toujours le 1er janvier 1970 à minuit.

difftime est une fonction inline qui prend la valeur _difftime32 ou _difftime64 selon que _USE_32BIT_TIME_T est défini. _difftime32 et _difftime64 peuvent être utilisés directement pour forcer l’utilisation d’une taille particulière du type d’heure.

Ces fonctions valident leurs paramètres. Si l’un des paramètres est égal à zéro ou négatif, le gestionnaire de paramètres non valide est appelé, comme décrit dans la validation des paramètres. Si l’exécution est autorisée à se poursuivre, ces fonctions retournent 0 et définissent errno avec la valeur EINVAL.

Par défaut, l’état global de cette fonction est limité à l’application. Pour modifier ce comportement, consultez État global dans le CRT.

Spécifications

Routine	En-tête requis
difftime	<time.h>
_difftime32	<time.h>
_difftime64	<time.h>

Pour plus d’informations sur la compatibilité, consultez Compatibility.

Exemple

// crt_difftime.c
// This program calculates the amount of time
// needed to do a floating-point multiply 100 million times.
//

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

double RangedRand( float range_min, float range_max)
{
   // Generate random numbers in the half-closed interval
   // [range_min, range_max). In other words,
   // range_min <= random number < range_max
   return ((double)rand() / (RAND_MAX + 1) * (range_max - range_min)
            + range_min);
}

int main( void )
{
   time_t   start, finish;
   long     loop;
   double   result, elapsed_time;
   double   arNums[3];

   // Seed the random-number generator with the current time so that
   // the numbers will be different every time we run.
   srand( (unsigned)time( NULL ) );

   arNums[0] = RangedRand(1, FLT_MAX);
   arNums[1] = RangedRand(1, FLT_MAX);
   arNums[2] = RangedRand(1, FLT_MAX);
   printf( "Using floating point numbers %.5e %.5e %.5e\n", arNums[0], arNums[1], arNums[2] );

   printf( "Multiplying 2 numbers 100 million times...\n" );

   time( &start );
   for( loop = 0; loop < 100000000; loop++ )
      result = arNums[loop%3] * arNums[(loop+1)%3];
   time( &finish );

   elapsed_time = difftime( finish, start );
   printf( "\nProgram takes %6.0f seconds.\n", elapsed_time );
}

Using random floating point numbers 1.04749e+038 2.01482e+038 1.72737e+038
Multiplying 2 floating point numbers 100 million times...
Program takes      3 seconds.

Voir aussi

Prise en charge mathématique et à virgule flottante
Gestion des horaires
time, _time32, _time64