Como você adicionar um atraso programado para um programa em C ++?

Question

Eu estou tentando adicionar um atraso cronometrado em um programa C ++, e queria saber se alguém tem alguma sugestão sobre o que eu posso tentar ou informações que eu posso olhar?

Eu gostaria de ter mais detalhes sobre como estou implementando este atraso cronometrado, mas até que eu tenha mais informações sobre como adicionar um atraso cronometrado eu não tenho certeza de como eu deveria sequer tentar implementar isso.

Answer 1

Win32: Sleep(milliseconds) é o que você o

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

sleep () só leva um número de segundos que muitas vezes é muito longo.

Answer 2

Uma resposta atualizado para o C ++ 11:

Use as funções sleep_for e 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_for e sleep_until são funções de modelo que pode aceitar valores de qualquer resolução via tipos chrono; horas, segundos, femtossegundos, etc.

Em C ++ 14 você pode simplificar ainda mais o código com os sufixos literais para nanoseconds e 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);
}

Note 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 milésimo de segundo em vez disso, se esse é o mais curto que pode fazer

Answer 3

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

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

Answer 4

Você quer algo tão simples como

sleep(3);

Answer 5

Note que isso não garante que a quantidade de tempo que os sonos de rosca será em qualquer lugar próximo ao período de sono, ele só garante que a quantidade de tempo antes que o segmento continua a execução será pelo menos a quantidade desejada. O atraso real irá variar, dependendo das circunstâncias (especialmente carregar na máquina em questão) e podem ser ordens de magnitude maior do que o tempo de sono desejado.

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

Answer 6

Você também pode usar select (2) se você quiser precisão microssegundo (Isso funciona em plataforma que não têm usleep (3))

O código a seguir irá esperar por 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);
}

`

Answer 7

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

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.

Answer 8

Sim, o sono é provavelmente a função de escolha aqui. Note-se que o tempo passado para a função é a menor quantidade de tempo que o segmento de chamada estará inativa. Por exemplo, se você chamar o sono com 5 segundos, você está garantida a sua discussão será dormir por pelo menos 5 segundos. Poderia ser 6 ou 8 ou 50, dependendo do que o OS está fazendo. (Durante a execução OS ideal, isso será muito perto de 5.)
Outra característica útil da função do sono é passar em 0. Isso forçará uma mudança de contexto de seu segmento.

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

Answer 9

Você pode tentar este trecho 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));
}

Answer 10

para saída de atraso na CPP de tempo fixo, você pode usar a função Sleep () através da inclusão de arquivo de cabeçalho windows.h sintaxe para Sleep () é a função do sono (time_in_ms) como

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

OUTPUT. acima código irá imprimir a Apple e aguarde 3 segundos antes de imprimir Mango.

Answer 11

Sintaxe:

sono void (não assinados segundos);

sleep () suspende a execução de um intervalo (segundos). Com uma chamada para o sono, o programa atual está suspensa a partir de execução para o número de segundos especificados pelos segundos argumento. O intervalo é preciso apenas para o centésimo de segundo mais próximo ou para a precisão do relógio do sistema operacional, o que é menos preciso.

Answer 12

Muitos outros têm fornecido boas informações para dormir. Concordo com Wedge que um sono raramente a solução mais adequada.

Se você está dormindo enquanto você espera por algo, então você está melhor fora realmente esperando por aquela coisa / evento. Olhe para variáveis ??de condição para isso.

Eu não sei o que OS você está tentando fazer isso, mas para threading e sincronização você pode olhar para o Impulsione Enfiar bibliotecas ( Impulsione Condição Varriable ).

Passando agora para o outro extremo, se você está tentando esperar por períodos excepcionalmente curto, então há um par de opções de estilo de hackers. Se você estiver trabalhando em algum tipo de plataforma embarcada onde um 'sono' não é implementada, então você pode tentar um loop simples (para / while etc) com um corpo vazio (cuidado o compilador não otimizá-lo de distância). É claro que o tempo de espera é dependente do hardware específico neste caso. Para 'espera' muito curtas, você pode tentar uma montagem "nop". Eu duvido que estes são o que você está depois, mas sem saber por que você precisa esperar é difícil ser mais específico.

Answer 13

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