Como você adiciona um atraso cronometrado a um programa C ++?

Estou tentando adicionar um atraso cronometrado em um programa C ++ e gostaria de saber se alguém tem alguma sugestão sobre o que posso tentar ou informações que posso olhar?

Gostaria de ter mais detalhes sobre como estou implementando esse atraso cronometrado, mas até ter mais informações sobre como adicionar um atraso cronometrado, não tenho certeza de como devo tentar implementar isso.

Win32: Sleep(milliseconds)é o que você

unix: usleep(microseconds)é o que você deseja.

sleep () leva apenas alguns segundos, o que geralmente é muito longo.

Uma resposta atualizada para C ++ 11:

Use as funções sleep_fore sleep_until:

#include <chrono>
#include <thread>

int main() {
    using namespace std::this_thread; // sleep_for, sleep_until
    using namespace std::chrono; // nanoseconds, system_clock, seconds

    sleep_for(nanoseconds(10));
    sleep_until(system_clock::now() + seconds(1));
}

Com estas funções não há mais a necessidade de adicionar continuamente novas funções para melhor resolução: sleep, usleep, nanosleep, etc. sleep_fore sleep_untilsão funções de modelo que pode aceitar valores de qualquer resolução via chronotipos; horas, segundos, femtossegundos, etc.

No C ++ 14, você pode simplificar ainda mais o código com os sufixos literais para nanosecondse seconds:

#include <chrono>
#include <thread>

int main() {
    using namespace std::this_thread;     // sleep_for, sleep_until
    using namespace std::chrono_literals; // ns, us, ms, s, h, etc.
    using std::chrono::system_clock;

    sleep_for(10ns);
    sleep_until(system_clock::now() + 1s);
}

Observe que a duração real de um sono depende da implementação: você pode pedir para dormir por 10 nanossegundos, mas uma implementação pode acabar dormindo por um milissegundo em vez disso, se esse for o menor tempo possível.

#include <unistd.h>
usleep(3000000);

Isso também dormirá por três segundos. Você pode refinar os números um pouco mais.

Você quer algo tão simples como

sleep(3);

Observe que isso não garante que a quantidade de tempo que o thread adormece será em qualquer lugar próximo ao período de hibernação, apenas garante que a quantidade de tempo antes de o thread continuar a execução será pelo menos a quantidade desejada. O atraso real irá variar dependendo das circunstâncias (especialmente da carga na máquina em questão) e pode ser ordens de magnitude maior do que o tempo de sono desejado.

Além disso, você não lista por que precisa dormir, mas geralmente deve evitar o uso de atrasos como método de sincronização.

Você pode tentar este snippet de código:

#include<chrono>
#include<thread>

int main(){
    std::this_thread::sleep_for(std::chrono::nanoseconds(10));
    std::this_thread::sleep_until(std::chrono::system_clock::now() + std::chrono::seconds(1));
}

Você também pode usar select (2) se quiser precisão de microssegundos (isso funciona em plataformas que não têm usleep (3))

O código a seguir aguardará 1,5 segundo:

#include <sys/select.h>
#include <sys/time.h>
#include <unistd.h>`

int main() {
    struct timeval t;
    t.tv_sec = 1;
    t.tv_usec = 500000;
    select(0, NULL, NULL, NULL, &t);
}

`

Sim, o sono é provavelmente a função de escolha aqui. Observe que o tempo passado para a função é a menor quantidade de tempo que o thread de chamada ficará inativo. Então, por exemplo, se você chamar o modo de espera com 5 segundos, você tem a garantia de que o thread estará dormindo por pelo menos 5 segundos. Pode ser 6, 8 ou 50, dependendo do que o sistema operacional está fazendo. (Durante a execução do sistema operacional ideal, isso será muito próximo de 5.)
Outro recurso útil da função dormir é passar 0. Isso forçará uma mudança de contexto de seu thread.

Algumas informações adicionais:
http://www.opengroup.org/onlinepubs/000095399/functions/sleep.html

Descobri que "_sleep(milliseconds);"(sem as aspas) funciona bem para Win32 se você incluir a chronobiblioteca

Por exemplo:

#include <chrono>

using namespace std;

main
{
    cout << "text" << endl;
    _sleep(10000); // pauses for 10 seconds
}

Certifique-se de incluir o sublinhado antes de dormir.

para atrasar a saída em cpp por um tempo fixo, você pode usar a função Sleep () incluindo a sintaxe do arquivo de cabeçalho windows.h para a função Sleep () é Sleep (time_in_ms) como

cout<<"Apple\n";
Sleep(3000);
cout<<"Mango";

RESULTADO. o código acima imprimirá Apple e esperará 3 segundos antes de imprimir Mango.

A principal resposta aqui parece ser uma resposta dependente do sistema operacional; para uma solução mais portátil, você pode escrever uma função de suspensão rápida usando o arquivo de cabeçalho ctime (embora isso possa ser uma implementação ruim da minha parte).

#include <iostream>
#include <ctime>

using namespace std;

void sleep(float seconds){
    clock_t startClock = clock();
    float secondsAhead = seconds * CLOCKS_PER_SEC;
    // do nothing until the elapsed time has passed.
    while(clock() < startClock+secondsAhead);
    return;
}
int main(){

    cout << "Next string coming up in one second!" << endl;
    sleep(1.0);
    cout << "Hey, what did I miss?" << endl;

    return 0;
}

Sintaxe:

void sleep (segundos sem sinal);

sleep () suspende a execução por um intervalo (segundos). Com uma chamada para dormir, o programa atual é suspenso da execução pelo número de segundos especificado pelo argumento segundos. O intervalo é preciso apenas até o centésimo de segundo mais próximo ou com a precisão do relógio do sistema operacional, o que for menos preciso.

Muitos outros forneceram boas informações para dormir. Concordo com Wedge que um sono raramente é a solução mais adequada.

Se você está dormindo enquanto espera por algo, então é melhor realmente esperar por essa coisa / evento. Veja as variáveis ​​de condição para isso.

Não sei em qual sistema operacional você está tentando fazer isso, mas para threading e sincronização, você pode olhar para as bibliotecas Boost Threading ( Boost Condition Varriable ).

Indo agora para o outro extremo, se você está tentando esperar por períodos excepcionalmente curtos, há algumas opções de estilo de hack. Se você está trabalhando em algum tipo de plataforma embutida onde um 'sono' não é implementado, você pode tentar um loop simples (para / enquanto, etc) com um corpo vazio (tome cuidado para que o compilador não o otimize). Claro que o tempo de espera depende do hardware específico neste caso. Para 'esperas' realmente curtas, você pode tentar uma montagem "nop". Eu duvido muito que isso seja o que você procura, mas sem saber por que você precisa esperar, é difícil ser mais específico.

No Windows, você pode incluir a biblioteca do Windows e usar "Sleep (0);" para dormir o programa. Leva um valor que representa milissegundos.