boost :: lockfree :: Warteschlange der Funktionen?

Question

Ich möchte eine einfache boost::lockfree::queue von Funktionen, die keine Argumente und keine Werte zurückgeben.

Es scheint, dass boost::lockfree::queue verlangt, dass der Elementtyp trivial zuweisbar und zerstörbar ist, Anforderungen, die boost::function<void()> leider nicht erfüllen.

Im Geiste der https://stackoverflow.com/a/21406186/393756, versuche ich jetzt dies durch eine boost::lockfree::queue von einfachen Funktionszeiger zu erreichen:

boost::lockfree::queue<void (*)()> queue; 

Kann ich einen boost::function<void()> in dieser Warteschlange schieben? Wenn ja, wie?

Answer 1

Kann ich einen boost::function<void()> in diese Warteschlange schieben?

Nicht direkt, wie boost::function<void()> ist ein Schwergewicht besitzender Typ-gelöschten Wrapper, die nicht implizit umwandelbar in einen Funktionszeiger und auch einige Daten gespeichert ist.

Wenn Sie eine trivialer zuweisbare eine trivialen-zerstörbare Art benötigen, die ein Funktionsobjekt verweisen kann, könnten Sie eine function_view Klasse implementieren, ohne es zu besitzen bis zu einem gewissen Funktionsobjekt verweist. Wenn Sie mit den Lebensdauern vorsichtig sind und sicherstellen, dass function_view immer auf "Live-Objekte" zeigt, können Sie Instanzen davon in Ihrer Warteschlange sicher speichern.

Konzeptionell function_view ist ein Paar Zeiger. Ich habe eine Implementierung in meinem "passing functions to functions" Artikel, die ich weiter unten einfügen bin:

template <typename TReturn, typename... TArgs> 
class function_view<TReturn(TArgs...)> final 
{ 
private: 
    using signature_type = TReturn(void*, TArgs...); 

    void* _ptr; 
    TReturn (*_erased_fn)(void*, TArgs...); 

public: 
    template <typename T, typename = std::enable_if_t< 
           std::is_callable<T&(TArgs...)>{} && 
           !std::is_same<std::decay_t<T>, function_view>{}>> 
    function_view(T&& x) noexcept : _ptr{(void*)std::addressof(x)} 
    { 
     _erased_fn = [](void* ptr, TArgs... xs) -> TReturn { 
      return (*reinterpret_cast<std::add_pointer_t<T>>(ptr))(
       std::forward<TArgs>(xs)...); 
     }; 
    } 

    decltype(auto) operator()(TArgs... xs) const 
     noexcept(noexcept(_erased_fn(_ptr, std::forward<TArgs>(xs)...))) 
    { 
     return _erased_fn(_ptr, std::forward<TArgs>(xs)...); 
    } 
}; 

Diese Klasse übergibt die folgenden Tests:

using type = function_view<void()>; 
static_assert(is_trivially_assignable<type, type>{}); 
static_assert(is_trivially_destructible<type>{}); 

live example on wandbox

Answer 2

nicht, aber Sie können dynamische Speicher verwenden Zuordnung + Typ Löschen für diese Ursache:

struct callback_back{ 

    virtual void execute() = 0; 
    ~callback_base() = default; 

}; 

template<class F> 
class callback{ 

    private: 
    F m_function; 

    public: 
    callback(F&& function) : m_function(std::forward<F>(function)){} 

    virtual void execute() { 
     m_function(); 
    } 

} 

template<class F> 
std::unique_ptr<callback_base> make_callback(F&& f){ 
    return std::unique_ptr<callback_base>(
     new callback<F>(std::forward<F>(f)); 
    ); 
} 

Verwenden Sie callback_base als No-Except-Movable-Typ (alias boost::lockfree::queue<std::unique_ptr<callback_base>>).