Exécuter une boucle infinie pendant un certain temps dans c

Question

Je veux exécuter une boucle infinie pendant un certain temps. Fondamentalement, je veux avoir quelque chose comme ça

//do something 

while(1){ 
    //do some work 
} 

//do some other thing 

, mais je veux le temps de fonctionnement de la boucle à fixer, par exemple, la boucle pourrait être en cours d'exécution pendant 5 secondes. Est-ce que quelqu'un a une idée?

Answer 1

Juste faire sleep(5) (inclure unistd.h). Vous pouvez l'utiliser comme ceci:

// do some work here 
someFunction();  

// have a rest 
sleep(5); 

// do some more work 
anotherFunction(); 

Si vous faites travail à l'intérieur de la boucle, vous pouvez faire (y compris time.h):

// set the end time to the current time plus 5 seconds 
time_t endTime = time(NULL) + 5; 

while (time(NULL) < endTime) 
{ 
    // do work here. 
} 

Answer 2

Essayez d'utiliser l'horloge().

#include <time.h> 

clock_t start = clock(); 

while (1) 
{ 
    clock_t now = clock(); 
    if ((now - start)/CLOCKS_PER_SEC > 5) 
     break; 

    // Do something 
} 

Answer 3

Pseudo-code:

starttime = ...; 

while(currentTime - startTime < 5){ 

} 

Answer 4

Non testé; la résolution est très grossière.

#include <time.h> 
#define RUNTIME 5.0 /* seconds */ 

double runtime = 0; 
double start = clock(); /* automatically convert clock_t to double */ 
while (runtime < RUNTIME/CLOCKS_PER_SEC) { 
    /* work */ 
    runtime = clock() - start; 
} 

Si/* travail */prend plus de 5 secondes, la boucle prendra plus de 5 secondes.

Si/* travail */prend 1,2 secondes, la boucle exécutera environ 5 fois pour un total de 6 secondes

Answer 5

Tout d'abord, pensez à utiliser la fonction sleep si possible. Si vous devez faire un travail réel pour une période de temps déterminée, que je trouve peu probable, la solution laide suivante fonctionnerait:

#include <signal.h> 
int alarmed = 0; 
void sigh(int signum) { 
    alarmed = 1; 
} 
int main(void){ 
    /* ... */ 
    signal(SIGALRM, &sigh); 
    alarm(5); // Alarm in 5 seconds 
    while(!alarmed) { 
     /* Do work */ 
    } 
    /* ... */ 
} 

Une solution à l'aide time.h serait également possible, et peut-être plus simple et/ou plus précis, selon le contexte:

#include <time.h> 
int main(void){ 
    /* ... */ 
    clock_t start = clock(); 
    while(clock() - start < 5 * CLOCKS_PER_SEC) { 
     /* Do work */ 
    } 
    /* ... */ 
} 

Answer 6

Si vous ne voulez pas appeler un temps à la fonction à chaque fois dans la boucle et sont sur un système qui a alarm (POSIXes comme Unix, Linux, BSD ...) vous pouvez faire:

statique volatil e int timeout = 0;

void handle_alrm(int sig) { 
    timeout = 1; 
} 

int main(void) { 
    signal(SIGALRM, handle_alrm); 
    ... 
    timeout = 0; 
    alarm(5); 
    while (!timeout) { 
     do_work(); 
    } 
    alarm(0); // If the signal didn't fire yet we can turn it off now. 
    ... 

Les signaux peuvent avoir d'autres effets secondaires (comme vous empêcher de passer des appels système). Vous devriez regarder dans ces derniers avant de les compter.