Bagaimana Anda menambahkan penundaan waktu ke program C ++?

Saya mencoba menambahkan penundaan waktu dalam program C ++, dan bertanya-tanya apakah ada yang punya saran tentang apa yang dapat saya coba atau informasi yang dapat saya lihat?

Saya berharap saya memiliki lebih banyak detail tentang bagaimana saya menerapkan penundaan berjangka waktu ini, tetapi sampai saya memiliki informasi lebih lanjut tentang cara menambahkan penundaan berwaktu, saya tidak yakin tentang bagaimana saya harus mencoba menerapkan ini.

Win32: Sleep(milliseconds)adalah apa yang Anda

unix: usleep(microseconds)adalah yang Anda inginkan.

sleep () hanya membutuhkan beberapa detik yang seringkali terlalu lama.

Jawaban terbaru untuk C ++ 11:

Gunakan sleep_fordan sleep_untilfungsi:

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

Dengan fungsi ini tidak ada lagi kebutuhan untuk terus menambahkan fungsi baru untuk resolusi yang lebih baik: sleep, usleep, nanosleep, dllsleep_for dan sleep_untilmerupakan fungsi template yang dapat menerima nilai-nilai dari setiap resolusi melalui chronojenis; jam, detik, femtoseconds, dll.

Di C ++ 14 Anda dapat lebih menyederhanakan kode dengan sufiks literal untuk nanosecondsdan 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);
}

Perhatikan bahwa durasi aktual tidur bergantung pada penerapannya: Anda dapat meminta tidur selama 10 nanodetik, tetapi penerapan mungkin akan berakhir dalam mode tidur selama satu milidetik, jika itu yang terpendek yang dapat dilakukan.

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

Ini juga akan tidur selama tiga detik. Anda bisa memperbaiki angkanya sedikit lagi.

Apakah Anda menginginkan sesuatu yang sederhana seperti

sleep(3);

Perhatikan bahwa ini tidak menjamin bahwa jumlah waktu thread tidur akan mendekati periode tidur, ini hanya menjamin bahwa jumlah waktu sebelum thread melanjutkan eksekusi akan setidaknya jumlah yang diinginkan. Penundaan sebenarnya akan bervariasi tergantung pada keadaan (terutama beban pada mesin yang bersangkutan) dan mungkin lipat lebih tinggi dari waktu tidur yang diinginkan.

Selain itu, Anda tidak mencantumkan mengapa Anda perlu tidur tetapi Anda biasanya harus menghindari penggunaan penundaan sebagai metode sinkronisasi.

Anda dapat mencoba cuplikan kode ini:

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

Anda juga dapat menggunakan pilih (2) jika Anda menginginkan presisi mikrodetik (ini berfungsi pada platform yang tidak memiliki mode tidur (3))

Kode berikut akan menunggu selama 1,5 detik:

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

`

Ya, tidur mungkin merupakan fungsi pilihan di sini. Perhatikan bahwa waktu yang dilewati ke fungsi adalah jumlah waktu terkecil thread pemanggil tidak aktif. Jadi misalnya jika Anda menyebut tidur dengan 5 detik, Anda dijamin utas Anda akan tidur setidaknya selama 5 detik. Bisa 6, atau 8 atau 50, tergantung pada apa yang dilakukan OS. (Selama eksekusi OS yang optimal, ini akan sangat mendekati 5.)
Fitur lain yang berguna dari fungsi tidur adalah memasukkan 0. Ini akan memaksa sakelar konteks dari utas Anda.

Beberapa informasi tambahan:
http://www.opengroup.org/onlinepubs/000095399/functions/sleep.html

Saya menemukan bahwa "_sleep(milliseconds);"(tanpa tanda kutip) berfungsi dengan baik untuk Win32 jika Anda menyertakan filechrono perpustakaan

Misalnya:

#include <chrono>

using namespace std;

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

Pastikan Anda memasukkan garis bawah sebelum tidur.

untuk menunda output di cpp untuk waktu tetap, Anda dapat menggunakan fungsi Sleep () dengan memasukkan sintaks file header windows.h untuk fungsi Sleep () adalah Sleep (time_in_ms) sebagai

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

KELUARAN. kode di atas akan mencetak Apple dan menunggu selama 3 detik sebelum mencetak Mango.

Jawaban teratas di sini tampaknya merupakan jawaban yang bergantung pada OS; untuk solusi yang lebih portabel Anda dapat menulis fungsi tidur cepat menggunakan file header ctime (meskipun ini mungkin implementasi yang buruk di pihak saya).

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

Sintaksis:

batal tidur (detik tak bertanda tangan);

sleep () menangguhkan eksekusi untuk suatu interval (detik). Dengan panggilan untuk tidur, program saat ini ditangguhkan dari eksekusi selama jumlah detik yang ditentukan oleh argumen detik. Interval hanya akurat hingga seperseratus detik terdekat atau keakuratan jam sistem operasi, mana saja yang kurang akurat.

Banyak orang lain telah memberikan info yang baik untuk tidur. Saya setuju dengan Wedge bahwa tidur jarang menjadi solusi yang paling tepat.

Jika Anda tidur sambil menunggu sesuatu, maka lebih baik Anda benar-benar menunggu hal / peristiwa itu. Lihat Variabel Kondisi untuk ini.

Saya tidak tahu OS apa yang Anda coba lakukan ini, tetapi untuk threading dan sinkronisasi Anda dapat melihat ke pustaka Boost Threading ( Boost Condition Varriable ).

Pindah sekarang ke ekstrem lain jika Anda mencoba menunggu dalam waktu yang sangat singkat maka ada beberapa opsi gaya peretasan. Jika Anda bekerja pada semacam platform tertanam di mana 'tidur' tidak diterapkan maka Anda dapat mencoba loop sederhana (untuk / sementara dll) dengan badan kosong (hati-hati kompiler tidak mengoptimalkannya). Tentu saja waktu tunggu tergantung pada perangkat keras tertentu dalam kasus ini. Untuk 'menunggu' yang sangat singkat, Anda dapat mencoba perakitan "nop". Saya sangat meragukan ini yang Anda cari, tetapi tanpa mengetahui mengapa Anda harus menunggu, sulit untuk lebih spesifik.

Di Windows, Anda dapat menyertakan pustaka windows dan menggunakan "Sleep (0);" untuk menghentikan program. Dibutuhkan nilai yang mewakili milidetik.