C++ 11: Wywoływanie C funkcja ++ okresowo

Question

mam połączyć prostą C++ klasy Timer, która ma wywołać określoną funkcję okresowo z różnych przykładów na SO następująco:

#include <functional> 
#include <chrono> 
#include <future> 
#include <cstdio> 

class CallBackTimer 
{ 
public: 
    CallBackTimer() 
    :_execute(false) 
    {} 

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

    void stop() 
    { 
     _execute = false; 
    } 

private: 
    bool   _execute; 
}; 

teraz chcę zadzwonić to z C++ klasa jako followsL

class Processor() 
{ 
    void init() 
    { 
     timer.start(25, std::bind(&Processor::process, this)); 
    } 

    void process() 
    { 
     std::cout << "Called" << std::endl; 
    } 
}; 

jednak wymaga to z błędem

terminate called after throwing an instance of 'std::bad_function_call' 
what(): bad_function_call 

Answer 1

PROBL W twoim kodzie jest to, że twoje wyrażenie lambda wewnątrz twojej funkcji "start" przechwytuje zmienne lokalne przez odniesienie, używając składni [&]. Oznacza to, że lambda przechwytuje zmienne interval i func przez odniesienie, które są zarówno zmiennymi lokalnymi do funkcji start(), a zatem znikają po powrocie z tej funkcji. Ale po powrocie z tej funkcji lambda wciąż żyje wewnątrz oddzielonej nici. Wtedy pojawia się wyjątek "zła funkcja wywołania", ponieważ próbuje wywołać func przez odniesienie do obiektu, który już nie istnieje.

Co trzeba zrobić, to uchwycić zmiennych lokalnych według wartości, ze składnią [=] na lambda, a więc:

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

To działa, gdy próbuję go.

Albo, można również wymienić się wartości, które chcesz uchwycić bardziej wyraźny (które generalnie zalecane dla lambda):

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

EDIT

Jak inni zwrócili uwagę, korzystanie oderwanego wątku nie jest doskonałym rozwiązaniem, ponieważ łatwo można zapomnieć zatrzymać wątek i nie można sprawdzić, czy już działa. Powinieneś także zrobić atomową flagę _execute, aby upewnić się, że nie zostanie ona zoptymalizowana, a odczyty/zapisy są wątkowane. Zamiast tego można to zrobić:

class CallBackTimer 
{ 
public: 
    CallBackTimer() 
    :_execute(false) 
    {} 

    ~CallBackTimer() { 
     if(_execute.load(std::memory_order_acquire)) { 
      stop(); 
     }; 
    } 

    void stop() 
    { 
     _execute.store(false, std::memory_order_release); 
     if(_thd.joinable()) 
      _thd.join(); 
    } 

    void start(int interval, std::function<void(void)> func) 
    { 
     if(_execute.load(std::memory_order_acquire)) { 
      stop(); 
     }; 
     _execute.store(true, std::memory_order_release); 
     _thd = std::thread([this, interval, func]() 
     { 
      while (_execute.load(std::memory_order_acquire)) { 
       func();     
       std::this_thread::sleep_for(
       std::chrono::milliseconds(interval)); 
      } 
     }); 
    } 

    bool is_running() const noexcept { 
     return (_execute.load(std::memory_order_acquire) && 
       _thd.joinable()); 
    } 

private: 
    std::atomic<bool> _execute; 
    std::thread _thd; 
};