Fonction difftime en C ++

Lors du calcul ou de l'exécution de toute opération, nous pourrions avoir besoin de n'importe quelle fonction pour calculer le temps total qui s'est écoulé jusqu'à présent ou fournir la différence de temps en secondes entre deux points. En C ++, il peut y avoir différentes façons d'effectuer cette tâche de manière inappropriée. Mais nous discuterons de la fonction intégrée de C ++, c'est-à-dire la fonction difftime (), car son nom indique qu'il calcule la différence de temps. Cette fonction est définie dans la bibliothèque . Ainsi, chaque fois que nous sommes prêts à calculer le temps, nous aurons besoin de cette bibliothèque dans le code source.

Syntaxe de difftime ()

Double difftime (Time_obj end, Time_OBJ start);

La fonction y prend deux paramètres. Ce sont les objets qui sont déclarés à travers l'objet du temps 'Time_obj'. L'un est la «fin» qui montre l'heure de fin de tout processus. En même temps, le second est le «démarrage» qui représente l'heure de début. La valeur de retour de la fonction diffime () renvoie la différence entre le temps en secondes obtenues à partir des deux objets décrits ci-dessus.

Cette fonction est associée au temps de fonction intégré () en C ++, car cette fonction renvoie le temps de calendrier actuel. Ceci est également présent dans le fichier d'en-tête de C++.

Implémentation de la fonction difftime ()

Exemple 1 # difftime () pour les produits

Pour trouver la différence entre deux fois en secondes, il est nécessaire d'ajouter la bibliothèque dans laquelle la fonction difftime () est définie. Dans le langage de programmation C ++, cette bibliothèque doit être utilisée.

#inclure
#inclure

Comme indiqué précédemment, dans le programme principal, deux objets, début et finition, sont nécessaires pour calculer la différence entre les temps. Ces deux objets sont déclarés en utilisant Time_time.

Time_t Start, Finis

Une autre variable avec le nom de nom d'un type de données long est déclarée qui stockera les résultats de l'opération. Chaque fois que la logique que nous voulons appliquer dans le programme, cela sera écrit à l'intérieur du corps des objets de début et de fin.

Time (& Start);
Temps (et finition);

Étant donné que l'objet de début commence l'heure et se poursuit pendant que la fonction / l'opération est en cours lorsque le processus est terminé, l'objet fini note le temps de fin. Par exemple, dans ce programme expliqué ci-dessous, nous avons utilisé un simple `` à la boucle '' pour calculer le produit de deux valeurs. Ces deux valeurs commencent à partir de 0 et se terminent à une grande valeur. La boucle externe «pour» se termine avant 1000, et la boucle intérieure se termine à 30000; À l'intérieur de la boucle «pour», le corps de chaque itération, le nombre de l'extérieur et le nombre de la boucle intérieure sont multipliés. Les variables «I» et «J» sont indiquées à chaque numéro après chaque itération, un nouveau numéro dans chaque cycle. Le résultat est stocké dans la variable «produit»

Produit = i * j;

Le temps requis que nous voulons obtenir est calculé via la fonction diffime. Comme cette fonction contient deux paramètres, la fonction sera donc:

Difftime (finition, début);

Cette fonction renverra le temps obtenu en soustrayant l'heure de début de l'heure d'arrivée.

Enregistrez maintenant le code source avec l'extension C. Nous utilisons un compilateur G ++ pour compiler un fichier C ++ et l'exécuter. Le fichier que nous avons utilisé ici est 'dif. C 'qui contient le code source, il est compilé et la sortie est stockée dans le fichier de sortie via' -o '.

$ g ++ -o dif dif.c
$ ./ dif

Vous pouvez voir que le temps requis est de 0 seconde. Cela signifie que la boucle imbriquée calculera le produit en 0 seconde. Dans le code ci-dessus, la valeur dans la boucle extérieure pour la boucle est plus petite que l'intérieure, donc la différence de temps était nulle car elle peut être calculée facilement. Et si la valeur dans la boucle intérieure devient plus petite que l'extérieur pour la boucle? Nous expliquerons ci-après. Les autres exigences sont les mêmes. Le produit sera calculé à l'intérieur de la boucle. Nous utiliserons les objets de démarrage et de fin pour noter les valeurs de démarrage et de fin.

Maintenant, enregistrez le code et exécutez-le. En exécution, vous verrez que cela prendra un certain temps. Par rapport à la situation précédente, cela ne prend que zéro seconde, et le résultat a été affiché brusquement, mais dans ce cas, il semble qu'il doit y avoir plus de zéro seconde.

Après quelques attentes, vous verrez la déclaration résultante. Selon cela, les boucles ont pris 62 secondes pour être exécutées afin que le produit de deux valeurs pendant chaque itération puisse être calculé.

Exemple 2 # difftime () pour les boucles imbriquées

Contrairement à la déclaration précédente, nous avons utilisé une bibliothèque différente ici.

Il n'est pas nécessaire de spécifier «iostream» et «ctime» ou toute autre bibliothèque à l'aide de cette bibliothèque. Les deux variables sont initialisées. Dans cet exemple, nous avons utilisé trois fois les boucles de boucles. Chaque boucle imbriquée se termine et la prochaine boucle imbriquée commence. Chaque boucle à l'intérieur de la boucle imbriquée a une valeur différente pour la variable i; Pour la variable J, les valeurs sont les mêmes pour la boucle intérieure.

De plus, nous n'avons rien calculé ni aucune opération. Seule l'exécution des boucles avait eu lieu. Les variables de démarrage et de fin observeront l'heure de départ et de fin.

Après chaque exécution, à la fin, la fonction difftime () est appelée pour exécuter la réponse.

Difftime (fin, démarrage)

Nous exécuterons le code source pour voir les secondes consommées dans l'exécution de trois boucles imbriquées.

Cela prendra 10 secondes pour les trois boucles collectivement.

Exemple 3 # difftime () pour un temps entre les dates

Pour calculer le décalage horaire par rapport au début du programme jusqu'à sa fin. Notre préoccupation de discussion est de calculer la différence en secondes à partir d'un jour spécifique jusqu'à maintenant. Ici, les dates ne sont pas mentionnées correctement. Mais le programme va récupérer la date actuelle du système. Ici, nous allons calculer la différence de temps en quelques secondes du jour du Nouvel An à maintenant.

L'objet de la bibliothèque temporelle est utilisé pour récupérer l'heure actuelle afin que la différence puisse être calculée. Ici, nous n'avons pas besoin des variables de début et de fin séparément.

Une structure du temps «Nouvel An» est initialisée ici. Nous utiliserons la variable «maintenant» pour obtenir l'heure actuelle.

C'est l'heure);

L'objet «TM» de la structure du Nouvel An déclarera les heures, les min, les secondes et le mois comme zéro. La fonction difftime sera appelée qui prendra maintenant (heure actuelle), et une autre fonction intégrée à l'intérieur du paramètre pour obtenir le Nouvel An en quelques secondes.

Secondes = difftime (maintenant, mktime (& newyear));

Exécutez maintenant le programme; Vous verrez que 6036632 secondes sont passées jusqu'à présent en fonction de la date actuelle de votre système.

Conclusion

«difftime () C ++» est une fonction qui traite de la récupération du temps en secondes obtenu en soustrayant le temps de départ de la fin de la fin; Ces deux variables d'un type d'objet temporel sont utilisées pour fournir du temps en quelques secondes. En terminant maintenant l'article, nous parlerons de quelques exemples que nous avons inclus dans l'article. Cette fonction aide également à fournir l'heure à partir d'une date spécifique jusqu'à présent, comme indiqué ci-dessus dans l'exemple.