0
votes

Façon de suivre l'heure actuelle avec une bonne précision

Je me demandais comment suivre l'heure actuelle en C à la plus grande précision possible. En particulier, je me demandais s'il y avait une fonction en C que Mimics Python's Time.Time ()?

J'ai trouvé le code ci-dessous, mais il arrondit les secondes. P>

#include <time.h>
int main() {
  time_t seconds;
  seconds = time(NULL);
}

c python

0 commentaires

3 Réponses :

1
votes

Si vous utilisez un système compatible Posix, vous pouvez essayer clock_geTime code> fonction. Il renvoie l'heure actuelle dans les nanosecondes.

#include <time.h>
#include <stdint.h>
int main() {
    struct timespec ts;
    clock_gettime(CLOCK_REALTIME, &ts);
    int64_t time_ns = ts.tv_sec * 1000000000LL + ts.tv_nsec;
    return 0;
}

1 commentaires

TSS.TV_SEC * 1000000000 PANLE DUBLIVE DE REALLILY A 32 bits TIME_T < / code> . Suggérer tts.tv_sec * 1000000000LL ou similaire pour assurer au moins une multiplication de 64 bits.


                        
                                            
                            
                                
                                    0
 votes
                                
                            
                            
                                
                                     Cela devrait aider: 
#include<stdio.h>
#include<time.h>

int main()
{
    clock_t t1, t2;
    t1 = clock();
    float diff = (t1 / 1000000.0F );
    printf("%f",diff);

    return 0;
}

                                

                                                                    
                                    
                                    
                                        2 commentaires
                                        
                                                                                            
                                                    Ne présumez pas que  horloge  a cette résolution. Utilisez  t1 / (float) horlogs_per_sec .                                                

                                                
                                                                                            
                                                    Pensée profonde,  double  aurait plus de sens ici. Après tout, OP veut  bonne précision , donc pas besoin de réduire ce que  clock_t  peut fournir. De plus, comme  diff  pourrait être petit, considérer  "% g" .                                                

                                                
                                                                                    

                                    

                                                            

                        

                        
                                            
                            
                                
                                    0
 votes
                                
                            
                            
                                
                                     Vous pouvez utiliser la fonction  horloge  code> de  time.h  code> pour mesurer le temps avec une précision extrême. 
 Il retournera le nombre d'horloges écoulées depuis un cadre de référence (qui est défini la mise en œuvre, mais elle est liée à l'exécution du programme).  P> 
double secs = now / CLOCKS_PER_SEC; // Result in seconds
double msecs = secs * 1000; // Result in milliseconds

                                

                                                                    
                                    
                                    
                                        4 commentaires
                                        
                                                                                            
                                                    Vous avez besoin d'un casting  double secs = (double) maintenant / horlogs_per_sec;  ainsi que sur certains systèmes, vous n'obtenez pas la résolution de millisecond à partir de  horloge () .                                                

                                                
                                                                                            
                                                    @Weathervane dans la pratique,  (double) maintenant  est ok, mais cela pourrait réduire la précision de  clock_t . Une alternative plus douce est  double secs = 1,0 * maintenant / horlogs_per_sec;  pour permettre à la division de se produire à la meilleure précision.                                                

                                                
                                                                                            
                                                    @ Restauration de chux Monica ou  Double Secs = / (Double) Clocks_per_sec;  Semblable à une autre réponse. Bien que  clock_t  s la précision n'est pas si géniale.                                                

                                                
                                                                                            
                                                    @Weathervane vrai en général. Pourtant,  clock_t  et  time_t  ne sont spécifiés que comme un scalaire. C'est à ce jour que les couts peuvent non seulement élargir un type, parfois ils seront étroits, alors j'essaie de les éviter à moins que aucune autre bonne solution n'existe. IAC, votre point sur la faiblesse de  maintenant / horlogs_per_sec;  reste valide.

Articles qui pourrait vous intéresser : Que puis-je utiliser pour la conversion d'entrée au lieu de scanf? Comment puis-je calculer a * b / c lorsque a et b sont tous deux plus petits que c, mais que a * b déborde? Comment vérifier si un pointeur void (void *) est l'un des deux types de données? L'écran LCD affiche des caractères aléatoires (MPLAB)