реализовать временную задержку в c

вот как вы можете сделать это на большинстве настольных систем:

#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
}

вот как вы можете сделать это на микрокомпьютере / процессор Вт/таймер:

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
}

переменные waitloop должны быть точно настроены, они работали довольно близко для моего компьютера, но частотная шкала делает ее очень неточной для современной настольной системы; поэтому не используйте там, если вы не обнажены до металла и не делаете таких вещей.

Регистрация sleep (3) man page или MSDN для сна

хотя многие реализации имеют time функция возвращает текущее время в секунд, есть никакой гарантии что каждая реализация будет делать это (например, некоторые могут вернуться МС, а не секунд). Таким образом, более портативным решением является использование difftime.

difftime гарантирует стандарт C вернуть разницу в время в секунд между time_t значения. Таким образом, мы можем написать портативную функцию временной задержки, которая будет работать на всех совместимых реализациях стандарт 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);
}

одно предостережение с time и difftime функции это то, что стандарт C никогда не указывает степень детализации. Большинство реализаций имеют степень детализации одну секунду. Хотя это нормально для длительных задержек несколько секунды!--28-->, наша функция задержки может ждать слишком долго для длительных задержек меньше одной секунды.

существует портативная стандартная альтернатива C:.

на clock функция возвращает наилучшее приближение реализации к процессорному времени, используемому программой с начала определенной реализацией эры, связанной только с вызовом программы. Чтобы определить время в секундах, значение возвращенный clock функция должна быть разделена на значение макроса CLOCKS_PER_SEC.

на clock решение функции очень похож на наш!--2--> функции решение:

#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);
}

в этом случае есть предостережение, подобноеtime и difftime: степень детализации clock функция оставлена для реализации. Например, машины с 32-разрядными значениями для clock_t с разрешением в микросекунд может в конечном итоге обернуть значение, возвращаемое clock после 2147 секунд (около 36 минут).

таким образом, рассмотрите возможность использования time и difftime реализация функции задержки для задержки продолжительностью по крайней мере, одна секунда и clock реализация для длительных задержек меньше одной секунды.

последнее слово предостережения: clock возвращает процессорного времени, а не календарь время; clock может не соответствовать фактическому времени (например, если процесс спит).

за задержки как одна минута, sleep() - Это хороший выбор.

Если когда-нибудь, вы хотите сделать паузу на задержках меньше одной секунды, вы можете рассмотреть poll() С тайм-аутом.

оба являются POSIX.

sleep(int) работает как хорошая задержка. На минуту:

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

это timer?

для WIN32 попробуйте http://msdn.microsoft.com/en-us/library/ms687012%28VS.85%29.aspx

попробовать sleep(int number_of_seconds)

вы можете просто вызвать функцию delay (). Поэтому, если вы хотите отложить процесс в 3 секунды, вызовите delay (3000)...

если вы уверены, что хотите ждать и никогда не прерываться, используйте sleep в POSIX или Sleep в Windows. В POSIX сон занимает время в секундах, поэтому, если вы хотите, чтобы время было Короче, есть такие разновидности, как usleep() который использует микросекунд. Сон в Windows занимает миллисекунды, редко вам нужна более тонкая гранулярность, чем это.

возможно, вы хотите подождать некоторое время, но хотите разрешить прерывания, возможно, в случае чрезвычайной ситуации. сон может быть прерван сигналы, но в этом случае есть лучший способ сделать это.

поэтому я на самом деле нашел на практике, что вы делаете, это ждать события или переменной условия с таймаутом.

в Windows ваш вызов WaitForSingleObject. В POSIX это pthread_cond_timedwait.

в Windows вы также можете использовать WaitForSingleObjectEx и тогда вы можете фактически "прервать" свой поток с любой поставленной в очередь задачей, вызвав QueueUserAPC. WaitForSingleObject (Ex) вернет код, определяющий, почему он вышел, чтобы вы знали когда он возвращает состояние "тайм-аут", что он действительно тайм-аут. Вы устанавливаете событие, которое он ждет, когда вы хотите его завершить.

С pthread_cond_timedwait вы можете передать сигнал переменной условия. (Если несколько потоков ждут на одном и том же, вам нужно будет транслировать, чтобы разбудить их всех). Каждый раз, когда он петляет, он должен проверять состояние. Ваш поток может получить текущее время и посмотреть, прошло ли оно, или он может посмотреть, выполнено ли какое-то условие, чтобы определить, что делать. Если у вас есть какая-то очередь, вы можете проверить ее. (У вашего потока автоматически будет заблокирован мьютекс, который он использовал для ожидания переменной условия, поэтому, когда он проверяет условие, у него есть единственный доступ к нему).

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

пишем этот код :

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");}

}