besoin d'appeler une fonction périodique à des intervalles de temps en c++

Je suis en train d'écrire un programme en c++ où j'ai besoin d'appeler une fonction périodique à des intervalles de temps, disons tous les 10ms. Je n'ai jamais fait quoi que ce soit lié au temps ou les horloges en c++, est-ce un moyen rapide et facile de problème ou de l'un de ceux où il n'y a pas de solution élégante?

Merci!

<chrono> a cette prise en charge.

OriginalL'auteur Execut1ve | 2014-01-11

  1. 14

    Une simple minuterie peut être mis en œuvre comme suit,

    #include <iostream>
#include <chrono>
#include <thread>
#include <functional>

void timer_start(std::function<void(void)> func, unsigned int interval)
{
    std::thread([func, interval]() {
        while (true)
        {
            func();
            std::this_thread::sleep_for(std::chrono::milliseconds(interval));
        }
    }).detach();
}


void do_something()
{
    std::cout << "I am doing something" << std::endl;
}

int main() {
    timer_start(do_something, 1000);

    while(true);
}

    Cette solution simple n'offre pas un moyen pour arrêter la minuterie. La minuterie continue à fonctionner jusqu'à ce que le programme est sorti.

    Cool, j'apprends à créer un nouveau fil à travers cet exemple, trop.
    Malheureusement, votre solution ne pourra pas faire ce qu'il a demandé. Il exécutera func avec interval retard entre les appels. Il ne sera pas exécuté func chaque interval. Si le func peut prendre un certain temps variable pour exécuter des temps de démarrage varient également.

    OriginalL'auteur user534498

  2. 8

    Pour compléter la question, le code de @user534498 peut être facilement adapté pour avoir le périodique tique intervalle.
    Il est juste nécessaire de déterminer la prochaine heure de début point à l'entrée de la minuterie boucle de fil et sleep_until que point de temps après l'exécution de la fonction. 

    #include <iostream>
#include <chrono>
#include <thread>
#include <functional>

void timer_start(std::function<void(void)> func, unsigned int interval)
{
  std::thread([func, interval]()
  { 
    while (true)
    { 
      auto x = std::chrono::steady_clock::now() + std::chrono::milliseconds(interval);
      func();
      std::this_thread::sleep_until(x);
    }
  }).detach();
}

void do_something()
{
  std::cout << "I am doing something" << std::endl;
}

int main()
{
  timer_start(do_something, 1000);
  while (true)
    ;
}
    Cette approche est la bonne, il suffit de se méfier que func() doit se terminer avant la fin de sleep_until!

    OriginalL'auteur florgeng

  3. 0

    Vous pourriez regarder dans filetage:

    Voici un intervalle de temps contrôlé fonction implémentée en C, en utilisant des pthreads.h, il devrait être un simple port de C++.
    L'exécution d'une fonction à intervalles spécifiques

    OriginalL'auteur JMercer

  4. 0

    Cela dépend de ce que vous feriez sur par intervalle - l'affichage de l'heure/ticker ou quelque chose d'autre, à l'endroit précis de l'écran/forme. Ou vous pouvez avoir besoin d'envoyer régulièrement des données pour certains la machine connectée (sur une douille ou un tuyau). Avez-vous vraiment besoin de 10 précision à la milliseconde?

    En fonction des besoins, en particulier l'exigence de précision, vous pouvez avoir thread dédié pour faire " quelque chose', puis d'attendre et de faire la même chose à nouveau. Ou, sur Windows, vous pouvez utiliser SetTimer qui déclencherait WM_TIMER événement sur chaque intervalle (il ne nécessite pas de fil). Vous pouvez également utiliser waitable de la minuterie, la minuterie multimédia etc.

    Au dernier, mais assez important - avez-vous besoin de plate-forme et le compilateur de compatibilité? Ce qui signifie que, quel système d'exploitation vous utilisez, ou si vous avez besoin indépendante de la plateforme? Quel compilateur caractéristiques que vous recherchez (C++11 et C++14 ou avant C++11).

    OriginalL'auteur Ajay

  5. 0

    Si vous codez avec Visual C++, vous pouvez ajouter un timer élément de la forme que vous souhaitez appeler une fonction périodique (ici on l'appelle ma forme est MainForm, et mon timer MainTimer). Ajoutez un appel à l'événement tick dans les "Événements". Le concepteur va ajouter cette ligne dans votre .h fichier:

    this->MainTimer->Enabled = true;
this->MainTimer->Interval = 10;
this->MainTimer->Tick += gcnew System::EventHandler(this, &MainForm::MainTimer_Tick);

    Puis, à chaque intervalle spécifiée (en ms), l'application va appeler cette fonction

    private: System::Void MainTimer_Tick(System::Object^  sender, System::EventArgs^  e) {
   ///Enter your periodic code there
}
    Remarque: c'est le C++/CLI code et pas C++standard.

    OriginalL'auteur RawBean

  6. 0

    Désolé, mais je n'ai pas trouver un design plus simple.

    Vous pourriez, faire une classe qui possède à la fois un fil, et un weak_ptr à lui-même,
    pour être un "titulaire" que le callable pouvez le voir en toute sécurité, parce que le callable
    va existe encore, même si l'objet est détruit. Vous ne voulez pas un bancales pointeur.

    template<typename T>
struct IntervalRepeater {
using CallableCopyable = T;
private:
weak_ptr<IntervalRepeater<CallableCopyable>> holder;
std::thread theThread;
IntervalRepeater(unsigned int interval,
CallableCopyable callable): callable(callable), interval(interval) {}
void thread() {
weak_ptr<IntervalRepeater<CallableCopyable>> holder = this->holder;
theThread = std::thread([holder](){
//Try to strongify the pointer, to make it survive this loop iteration,
//   and ensure that this pointer is valid, if not valid, end the loop.
while (shared_ptr<IntervalRepeater<CallableCopyable>> ptr = holder.lock()) {
auto x = chrono::steady_clock::now() + chrono::milliseconds(ptr->interval);
ptr->callable();
this_thread::sleep_until(x);
}
});
}
public:
const CallableCopyable callable;
const unsigned int interval;
static shared_ptr<IntervalRepeater<T>> createIntervalRepeater(unsigned int interval,
CallableCopyable callable) {
std::shared_ptr<IntervalRepeater<CallableCopyable>> ret =
shared_ptr<IntervalRepeater<CallableCopyable>>(
new IntervalRepeater<CallableCopyable>(interval, callable));
ret->holder = ret;
ret->thread();
return ret;
}
~IntervalRepeater() {
//Detach the thread before it is released.
theThread.detach();
}
};
void beginItWaitThenDestruct() {
auto repeater = IntervalRepeater<function<void()>>::createIntervalRepeater(
1000, [](){ cout << "A second\n"; });
std::this_thread::sleep_for(std::chrono::milliseconds(3700));
}
int main() {
beginItWaitThenDestruct();
//Wait for another 2.5 seconds, to test whether there is still an effect of the object
//  or no.
std::this_thread::sleep_for(std::chrono::milliseconds(2500));
return 0;
}

    OriginalL'auteur user9335240