Wat is de methode om een timer in c te gebruiken? Ik moet wachten tot 500 ms voor een baan. Vermeld alstublieft een goede manier om deze baan te doen. Ik gebruikte sleep(3);
Maar deze methode heeft geen werk in die tijdsduur te doen. Ik heb iets dat tot die tijd zal proberen om invoer te krijgen.
Antwoord 1, Autoriteit 100%
U kunt een time_t
structuren gebruiken en clock()
functie van time.h .
Bewaar de starttijd in een time_t
struct door het gebruik van clock()
en controleer de verstreken tijd door het verschil tussen opgeslagen tijd en de huidige tijd te vergelijken.
Antwoord 2, Autoriteit 217%
Hier is een oplossing die ik gebruikte (het heeft #include <time.h>
):
int msec = 0, trigger = 10; /* 10ms */
clock_t before = clock();
do {
/*
* Do something to busy the CPU just here while you drink a coffee
* Be sure this code will not take more than `trigger` ms
*/
clock_t difference = clock() - before;
msec = difference * 1000 / CLOCKS_PER_SEC;
iterations++;
} while ( msec < trigger );
printf("Time taken %d seconds %d milliseconds (%d iterations)\n",
msec/1000, msec%1000, iterations);
Antwoord 3, Autoriteit 67%
Ja, je hebt een lus nodig. Als u al een hoofdlus (de meeste GUI-event-driven dingen doet) kunt u waarschijnlijk uw timer steken in die. Gebruik:
#include <time.h>
time_t my_t, fire_t;
Dan (voor tijden gedurende 1 seconde), initialiseer uw timer door de huidige tijd te lezen:
my_t = time(NULL);
Voeg het aantal seconden toe dat uw timer moet wachten en opslaan in Fire_t. Een time_t is in wezen een Uint32_t, misschien moet je het casten.
Binnen in je loop doe een andere
my_t = time(NULL);
Als (my_t & gt; fire_t), overweeg dan de timer ontslagen en doe de dingen die je daar wilt. Dat zal het waarschijnlijk opnemen het opnieuw instellen door een ander vuur te doen = tijd (null) + seconden_to_wait voor de volgende keer.
Een TIMET_T is een enigszins geëntische Unix-methode voor het opslaan van tijd als het aantal seconden sinds middernacht 1/1/1970, maar het heeft veel voordelen. Gedurende tijden van minder dan 1 seconde moet je GetTimeofday () (Microseconden (Microseconden) of Clock_GetTime () (Nanoseconden) gebruiken en omgaan met een struct-timeval of struct-tijdrespec, die een time_t en de microseconden of nanoseconden is, sinds die 1 seconde. Het maken van een timer werkt op dezelfde manier behalve wanneer u uw tijd toevoegt om te wachten, moet u onthouden om handmatig de draagkracht (in de time_t) te doen als de resulterende microseconden of nanoseconds-waarde langer dan 1 seconde gaat. Ja, het is rommelig. Zie man 2 keer, man gettimeofday, man Clock_getime.
Slaap (), USLEEP (), Nanosleep () heeft een verborgen voordeel. Je ziet het als het pauzeren van je programma, maar wat ze echt doen, is de CPU voor die hoeveelheid tijd vrijgeven. Herhaaldelijk pollen door de tijd te lezen en te vergelijken met de voltooide tijd (zijn we er al?) Zullen veel CPU-cycli verbranden die andere programma’s op dezelfde machine (en meer elektriciteit / batterij kunnen vertragen. Het is beter om () meestal te slapen, dan begint met het controleren van de tijd.
Als u probeert te slapen en tegelijkertijd te werken, hebt u discussies nodig.
Antwoord 4, Autoriteit 17%
Mogen deze voorbeelden helpen bij u
#include <stdio.h>
#include <time.h>
#include <stdlib.h>
/*
Implementation simple timeout
Input: count milliseconds as number
Usage:
setTimeout(1000) - timeout on 1 second
setTimeout(10100) - timeout on 10 seconds and 100 milliseconds
*/
void setTimeout(int milliseconds)
{
// If milliseconds is less or equal to 0
// will be simple return from function without throw error
if (milliseconds <= 0) {
fprintf(stderr, "Count milliseconds for timeout is less or equal to 0\n");
return;
}
// a current time of milliseconds
int milliseconds_since = clock() * 1000 / CLOCKS_PER_SEC;
// needed count milliseconds of return from this timeout
int end = milliseconds_since + milliseconds;
// wait while until needed time comes
do {
milliseconds_since = clock() * 1000 / CLOCKS_PER_SEC;
} while (milliseconds_since <= end);
}
int main()
{
// input from user for time of delay in seconds
int delay;
printf("Enter delay: ");
scanf("%d", &delay);
// counter downtime for run a rocket while the delay with more 0
do {
// erase the previous line and display remain of the delay
printf("\033[ATime left for run rocket: %d\n", delay);
// a timeout for display
setTimeout(1000);
// decrease the delay to 1
delay--;
} while (delay >= 0);
// a string for display rocket
char rocket[3] = "-->";
// a string for display all trace of the rocket and the rocket itself
char *rocket_trace = (char *) malloc(100 * sizeof(char));
// display trace of the rocket from a start to the end
int i;
char passed_way[100] = "";
for (i = 0; i <= 50; i++) {
setTimeout(25);
sprintf(rocket_trace, "%s%s", passed_way, rocket);
passed_way[i] = ' ';
printf("\033[A");
printf("| %s\n", rocket_trace);
}
// erase a line and write a new line
printf("\033[A");
printf("\033[2K");
puts("Good luck!");
return 0;
}
Bestand compileren, uitvoeren en verwijderen na (mijn voorkeur)
$ gcc timeout.c -o timeout && ./timeout && rm timeout
Probeer het zelf uit om het resultaat te zien.
Opmerkingen:
Testomgeving
$ uname -a
Linux wlysenko-Aspire 3.13.0-37-generic #64-Ubuntu SMP Mon Sep 22 21:28:38 UTC 2014 x86_64 x86_64 x86_64 GNU/Linux
$ gcc --version
gcc (Ubuntu 4.8.5-2ubuntu1~14.04.1) 4.8.5
Copyright (C) 2015 Free Software Foundation, Inc.
This is free software; see the source for copying conditions. There is NO
warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.