mettre en œuvre le délai dans c

Voici comment vous pouvez le faire sur la plupart des systèmes de bureau:

#ifdef _WIN32
    #include <windows.h>
#else
    #include <unistd.h>
#endif

void wait( int seconds )
{   // Pretty crossplatform, both ALL POSIX compliant systems AND Windows
    #ifdef _WIN32
        Sleep( 1000 * seconds );
    #else
        sleep( seconds );
    #endif
}

int
main( int argc, char **argv)
{
    int running = 3;
    while( running )
    {   // do something
        --running;
        wait( 3 );
    }
    return 0; // OK
}

Voici comment vous pouvez le faire sur un micro-ordinateur / processeur sans minuterie:

int wait_loop0 = 10000;
int wait_loop1 = 6000;

// for microprocessor without timer, if it has a timer refer to vendor documentation and use it instead.
void
wait( int seconds )
{   // this function needs to be finetuned for the specific microprocessor
    int i, j, k;
    for(i = 0; i < seconds; i++)
    {
        for(j = 0; j < wait_loop0; j++)
        {
            for(k = 0; k < wait_loop1; k++)
            {   // waste function, volatile makes sure it is not being optimized out by compiler
                int volatile t = 120 * j * i + k;
                t = t + 5;
            }
        }
    }
}

int
main( int argc, char **argv)
{
    int running = 3;
    while( running )
    {   // do something
        --running;
        wait( 3 );
    }
    return 0; // OK
}

Les variables waitloop doivent être affinées, celles-ci ont fonctionné assez près pour mon ordinateur, mais l'échelle de fréquence le rend très imprécis pour un système de bureau moderne; alors ne l'utilisez pas sauf si vous êtes nu au métal et ne faites pas de telles choses.

Vérifiez la page de manuelsleep(3) ou MSDN pour Sleep

Bien que de nombreuses implémentations aient time la fonction renvoie l'heure actuelle en secondes , Il n'y a aucune garantie que chaque implémentation le fera (par exemple, certaines peuvent renvoyer millisecondes plutôt que secondes). En tant que tel, une solution plus portable consiste à utiliser le difftime fonction.

difftime est garanti par la norme C {[40] } pour renvoyer la différence de temps en secondes entre deux valeurs time_t. Comme nous pouvons ainsi écrire une fonction de temporisation portable qui fonctionnera sur toutes les implémentations conformes de la norme C .

#include <time.h>

void delay(double dly){
    /* save start time */
    const time_t start = time(NULL);

    time_t current;
    do{
        /* get current time */
        time(&current);

        /* break loop when the requested number of seconds have elapsed */
    }while(difftime(current, start) < dly);
}

Une mise en garde avec les fonctions time et difftime est que la norme C ne spécifie jamais de granularité. La plupart des implémentations ont une granularité de une seconde. Bien que cela soit correct pour les retards qui durent plusieurs secondes , notre fonction de retard peut attendre trop longtemps pour les retards qui durent sous un deuxième.

Il existe une alternative portable standard C: la fonction clock.

Le clock la fonction renvoie la meilleure approximation de l'implémentation au temps de processeur utilisé par le programme depuis le début d'une ère définie par l'implémentation liée uniquement à l'invocation du programme. Pour déterminer le temps en secondes, la valeur retournée par la clock la fonction doit être divisée par la valeur de la macro CLOCKS_PER_SEC.

La solution de fonction clock est assez similaire à notre solution de fonction time:

#include <time.h>

void delay(double dly){
    /* save start clock tick */
    const clock_t start = clock();

    clock_t current;
    do{
        /* get current clock tick */
        current = clock();

        /* break loop when the requested number of seconds have elapsed */
    }while((double)(current-start)/CLOCKS_PER_SEC < dly);
}

Il y a une mise en garde dans ce cas similaire à celle de time et difftime: la granularité de la fonction clock est laissée à l'implémentation. Par exemple, les machines avec des valeurs 32 bits pour clock_t avec une résolution en microsecondes peuvent finir par envelopper la valeur renvoyée par clock après 2147 secondes (environ 36 minutes).

En tant que tel, envisagez d'utiliser time et difftime la mise en œuvre de la fonction de retard pour des retards d'une durée d'au moins une seconde, et la mise en œuvre clock pour des retards d'une durée inférieure à une seconde.

Un dernier mot de mise en garde: clock renvoie l'heure du processeur plutôt que l'heure du calendrier; clock peut ne pas correspondre au temps écoulé réel (par exemple si le processus dort).

Pour des retards aussi importants qu'une minute, sleep() est un bon choix.

Si un jour, vous voulez faire une pause sur les retards de moins d'une seconde, vous pouvez envisager poll() avec un délai d'attente.

Les deux sont POSIX.

sleep(int) fonctionne comme un bon délai. Pour une minute:

//Doing some stuff...
sleep(60); //Freeze for A minute
//Continue doing stuff...

Est-ce timer?

Pour WIN32 try http://msdn.microsoft.com/en-us/library/ms687012%28VS.85%29.aspx

Essayez sleep(int number_of_seconds)

Vous pouvez simplement appeler la fonction delay (). Donc, si vous voulez retarder le processus en 3 secondes, appelez delay (3000)...

Si vous êtes certain de vouloir attendre et ne jamais être interrompu, utilisez sleep dans POSIX ou Sleep dans Windows. Dans POSIX, le sommeil prend du temps en secondes, donc si vous voulez que le temps soit plus court, il existe des variétés comme usleep() qui utilisent des microsecondes. Le sommeil dans Windows prend des millisecondes, il est rare que vous ayez besoin d'une granularité plus fine que cela.

Il se peut que vous souhaitiez attendre un certain temps mais que vous souhaitiez autoriser des interruptions, peut-être en cas d'urgence. le sommeil peut être interrompu par des signaux, mais il y a une meilleure façon de le faire dans ce cas.

Par conséquent, j'ai effectivement trouvé dans la pratique ce que vous faites est d'attendre un événement ou une variable de condition avec un délai d'attente.

Dans Windows votre appel est WaitForSingleObject. En POSIX c'est pthread_cond_timedwait.

Dans Windows, vous pouvez également utiliser WaitForSingleObjectEx et puis vous pouvez interrompre votre discussion avec toute tâche en file d'attente en appelant QueueUserAPC. WaitForSingleObject (Ex) retournera un code déterminant pourquoi il est sorti, de sorte que vous saurez quand il retourne un statut "TIMEDOUT" qui il a fait en effet timeout. Vous définissez l'événement qu'il attend quand vous voulez qu'il se termine.

Avec pthread_cond_timedwait Vous pouvez signaler la diffusion de la variable de condition. (Si plusieurs threads attendent sur le même, vous devrez diffuser pour les réveiller tous). Chaque fois qu'il boucle, il devrait vérifier la condition. Votre thread peut obtenir l'heure actuelle et voir si elle est passée ou si une condition a été remplie pour déterminer ce qu'il faut faire. Si vous avez une sorte de file d'attente vous pouvez vérifier. (Votre thread aura automatiquement un mutex verrouillé qu'il a utilisé pour attendre sur la variable condition, donc quand il vérifie la condition, il a seul accès à elle).

system("timeout /t 60"); // waits 60s. this is only for windows vista,7,8
system("ping -n 60 127.0.0.1 >nul"); // waits 60s. for all windows

Écrivez ce code:

void delay(int x)
{   int i=0,j=0;
    for(i=0;i<x;i++){for(j=0;j<200000;j++){}}
}

int main()
{
    int i,num;

    while(1) {

    delay(500);

    printf("Host name");
    printf("\n");}

}