3. std::function und std::bind durch einfachere eigene Variante ersetzen (signal/slot)

std::function und std::bind durch einfachere eigene Variante ersetzen (signal/slot)

  • F

    @Meep Meep

    Wenn ich deinen Code nicht vollständig falsch verstanden habe, dann kann er aber nur einen Empfänger benachrichtigen!?

    @all

    Nach Meep Meep seinem Code bin ich dann drauf gekommen, dass ich bei mir das Signal-Slot Konzept mit Hilfe von std::function und std::bind umgesetzt habe.

    Dies würde ich gerne, wie schon geschrieben, gegen etwas eigenes (oder offenem anderen Code) ersetzen, was die Standard-Library nicht benutzt.

    Ich wollte ganz einfach anfangen und nur ein Signal haben, welches alle seine bei Ihm registrierten Slots durchgeht und den Handler ausführt.
    Allerdings bekomme ich das schon nicht mit meinen bescheidenen Template Kenntnissen hin.

    Die Anforderungen sind im Prinzip recht einfach, ein Slot ist entweder eine template Klasse die einen Funktionspointer speichert oder eine template Klasse die einen Memberfunktionspointer und einen Objektpointer speichert. Das Signal kann Slots beider Varianten "aufnehmen" (wobei das Signal nur einen Pointer auf das Erste Elemente einer einfach verketteten Liste speichert) und geht diese Liste durch und ruft die Handler der Slots auf.

    In Pseudocode formuliert:

    class ISlot
{
private:
    *ISlot _next;
public:
    ISlot()
    : _next(nullptr) {}
    ~ISlot() {}

    virtual void operator()(ARGS) = 0;

    ISlot* getNext()
    {
        return _next;
    }

    void setNext(ISlot* next)
    {
        _next = next;
    }
};

class SlotFunctionPointer : public ISlot
{
private:
    FunctionPointer* _function;
public:
    SlotFunctionPointer(FunctionPointer* function)
        : _function(function) {}
    ~SlotFunctionPointer() {}

    virtual void operator()(ARGS)
    {
        _function(ARGS);
    }
};

class SlotFunctionMemberPointer : public ISlot
{
private:
    FunctionMemberPointer* _function;
    ObjectPointer* _object
public:
    SlotFunctionPointer(FunctionMemberPointer* function, ObjectPointer* object)
        : _function(function),
        _object(object) {}
    ~SlotFunctionPointer() {}

    virtual void operator()(ARGS)
    {
        object->*_function(ARGS);
    }
};

class Signal
{
private:
    ISlot* _head;
public:
    Signal()
        : _head(nullptr) {}
    ~Signal() {}

    void operator()(ARGS)
    {
        ISlot* walker = _head;

        while(walker != nullptr)
        {
            walker();

            walker = walker->getNext();
        }
    }

    void connectSlot(ISlot* slot)
    {
        slot->setNext(_head);

        _head = slot;
    }
};

    Allerdings reichen meine Template Kenntnisse nicht dafür aus wie ich den Pseudo-Code in funktionierenden C++11/14 Code bekomme.

    Daher bin ich für jeden Tipp/Link/Vorschlag dankbar.

    0
  • S

    FlashBurn schrieb:

    Dies würde ich gerne, wie schon geschrieben, gegen etwas eigenes (oder offenem anderen Code) ersetzen, was die Standard-Library nicht benutzt.

    Warum das denn? Zur Übung? In der tatsächlichen Anwendung würde ich dir dringend dazu raten, die standard Bibliothek zu benutzen. Die ist vielfach getestet und daher wahrscheinlich fehlerfreier als dein Code und höchst wahrscheinlich auch perfomanter bzw. vom Compiler besser zu optimieren.

    0

  • Es gibt schon Gründe, warum man eine nicht-STL Lösung benutzen möchte. std::function Objekte sind zB nicht vergleichbar, das macht das Handling unter Umständen schwierig, zB wenn man einen vector pflegt und wissen möchte, ob eine Callback bereits registriert ist oder nicht. Oder einen bestimmten Callback löschen möchte.

    Vielleicht hilft dir das hier weiter:
    Impossibly fast delegates C++03 und
    Impossibly fast delegates C++11

    0
  • F

    Schlangenmensch schrieb:

    Warum das denn?

    Wie schon geschrieben, kann ich bei Verwendung von std::function und std::bind nicht ausschließen das new benutzt wird und genau das will ich verhindern.

    Der Code läuft auf einem Embedded System und dort habe ich nur wenig bis keinen Speicher für new/malloc zur Verfügung.

    Edit::

    @ DocShoe

    Danke, die sehe ich mir mal an.

    0
  • S

    Ah, es geht darum speziell std::function und ähnliches nicht aus der std zu benutzen. Ich hatte die Aussage irgendwie so verstanden, dass du gar keine Teile aus der std benutzen möchtest.

    Also ist das Ziel, sowas zu implementieren ohne das Speicher auf dem Heap benötigt wird?

    0
  • F

    Schlangenmensch schrieb:

    Ah, es geht darum speziell std::function und ähnliches nicht aus der std zu benutzen. Ich hatte die Aussage irgendwie so verstanden, dass du gar keine Teile aus der std benutzen möchtest.

    Also ist das Ziel, sowas zu implementieren ohne das Speicher auf dem Heap benötigt wird?

    Genau 😃

    0
  • F

    Bisher habe ich:

    template<typename Signature>
class ISlot;

template<typename RET, typename... ARGS>
class ISlot<RET(ARGS...)>
{
private:
	ISlot* _next;
public:
	ISlot()
		: _next(nullptr) {}
	~ISlot() {}

	virtual void handler(ARGS...) = 0;

	ISlot* getNext()
	{
		return _next;
	}

	void setNext(ISlot* next)
	{
		_next = next;
	}
};

template<typename Signature>
class Signal;

template<typename RET, typename... ARGS>
class Signal<RET(ARGS...)>
{
private:
	ISlot<void(ARGS...)>* _head;
public:
	Signal()
		: _head(nullptr) {}
	~Signal() {}

	void operator()(ARGS... args)
	{
		ISlot<void(ARGS...)>* walker = _head;

		while (walker != nullptr)
		{
			walker->handler(args...);

			walker = walker->getNext();
		}
	}

	void connectSlot(ISlot<void(ARGS...)>* slot)
	{
		slot->setNext(_head);

		_head = slot;
	}
};

    Wobei mir nicht 100% klar ist warum es funktioniert 😉

    Jetzt muss ich noch die Slots für Funktionspointer und für Memberfunktionspointer hinbekommen und ich habe genau das was ich haben wollte.

    0
  • F

    Die templates für die Funktionspointer sehen so aus:

    template<typename Signature>
class SlotFunctionPointer;

template<typename RET, typename... ARGS>
class SlotFunctionPointer<RET(ARGS...)> : public ISlot<void(ARGS...)>
{
private:
	void (*_function)(ARGS...);
public:
	SlotFunctionPointer(void(*function)(ARGS...))
		: _function(function) {}
	~SlotFunctionPointer() {}

	virtual void handler(ARGS... args)
	{
		_function(args...);
	}
};

    Jetzt nur noch die Templates für Memberfunktionspointer, aber ich weiß jetzt schon, das wird deutlich kniffliger.

    0
  • F

    Die templates für die Memberfunktionspointer sehen so aus:

    template<typename Signature, Signature>
class SlotFunctionMemberPointer;

template<typename T, typename RET, typename... ARGS, RET (T::*F)(ARGS...)>
class SlotFunctionMemberPointer<RET(T::*)(ARGS...), F> : public ISlot<void(ARGS...)>
{
private:
	T* _object;
public:
	SlotFunctionMemberPointer(T* object)
		: _object(object) {}
	~SlotFunctionMemberPointer() {}

	virtual void handler(ARGS... args)
	{
		(_object->*F)(args...);
	}
};

    Ein Testprogramm sieht so aus:

    class TestClassSignal
{
public:
	Signal<void(int, int)> signalTest;

	TestClassSignal() {}
	~TestClassSignal() {}
};

void testHandler(int a, int b)
{
	std::cout << a << " " << b << std::endl;
}

class TestClassSlot
{
public:
	TestClassSlot()
		: slot(this) {}

	void handler(int a, int b)
	{
		std::cout << (a * 10) << " " << (b * 10) << std::endl;
	}

	SlotFunctionMemberPointer<void (TestClassSlot::*)(int, int), &TestClassSlot::handler> slot;
};

int main()
{
	TestClassSignal						testSignal;
	SlotFunctionPointer<void(int, int)> testSlot1(&testHandler);
	TestClassSlot						testSlot2;

	testSignal.signalTest.connectSlot(&testSlot1);
	testSignal.signalTest.connectSlot(&testSlot2.slot);
	testSignal.signalTest(1, 2);

    return 0;
}

    Mal sehen, vielleicht bekomme ich es morgen noch hin die Templates zu verbessern, das sie nicht mehr so viele Parameter brauchen.

    0
  • Mod

    Polymorphe Wrapper können auch mit Stack Speicher auskommen. Hier eine Demo mit Memberfunktionszeigern. Allerdings ist die Function durch die ganzen pointer to member ziemlich riesig. 80 Byte bei 16 Byte payload. Mit gewöhnlichen Funktionszeigern und statischen Memberfunktionstemplates kann das natürlich gedeckelt werden.

    Falls dir eine zusätzliche Indirektion nichts ausmacht, bist du mit einer polymorphen Lösung aber vielleicht besser bedient:

    #include <functional>
#include <cstddef>

template <typename Signature, std::size_t N>
class Function;
template <typename R, typename... Args, std::size_t N>
class Function<R(Args...), N>
{
  std::aligned_storage_t<N> _storage;

  struct InvokerBase {
    virtual R operator()(void const*, Args...) const = 0;
    virtual void destroy(void*) = 0;
    virtual void copy(void const*, void*, void*) const = 0;
    virtual void move(void*, void*, void*) const = 0;
    virtual std::type_info const& type() const noexcept;
  };

  template <typename F>
  struct Invoker : InvokerBase {
    static_assert(sizeof(F) <= N);

    R operator()(void const* p, Args... args) const override {
      return std::invoke(*std::launder((F const*)p), std::forward<Args>(args)...);
    }
    void destroy(void* p) override {
      std::launder((F*)p)->~F();
    }
    void copy(void const* s, void* d, void* invoker_d) const override {
      new (d) F(*std::launder((F const*)s));
      new (invoker_d) Invoker;
    }
    void move(void* s, void* d, void* invoker_d) const override {
      new (d) F(std::move(*std::launder((F*)s)));
      new (invoker_d) Invoker;
    }
    std::type_info const& type() const noexcept {
      return typeid(F);
    }
  };

  std::aligned_storage_t<sizeof(Invoker<char>), alignof(Invoker<char>)> _invoker_storage;
  InvokerBase const& _invoker_base() const noexcept  {
    return *std::launder((InvokerBase*)&_invoker_storage); }
  InvokerBase& _invoker_base() noexcept  {
    return *std::launder((InvokerBase*)&_invoker_storage); }
  bool _empty;

  void _clear() {
    if (!empty()) {
      _invoker_base().destroy(&_storage);
      _empty = true;
    }
  }

  template <typename F>
  static const bool _is_callable =
    std::is_convertible_v<std::invoke_result_t<F, Args...>, R>;

  template <typename F>
  static const bool _participate = _is_callable<F>
                                && !std::is_same_v<std::decay_t<F>, Function>;

  template <typename>
  struct _is_function_spec : std::false_type{};
  template <typename X, std::size_t M>
  struct _is_function_spec<Function<X, M>> : std::true_type{};

  // Assumes that *this is empty.
  template <typename F>
  void _emplace(F&& f) {
    using T = std::decay_t<F>;
    if constexpr(std::is_pointer_v<T> || std::is_member_function_pointer_v<T> || _is_function_spec<T>{})
      if (!f)
        return;

    static_assert(sizeof(Invoker<F>) <= sizeof(_invoker_storage));
    new (&_storage) F(std::forward<F>(f));
    new (&_invoker_storage) Invoker<F>;
    _empty = false;
  }

public:

  using result_type = R;

  template <typename F>
  F const* target() const {
    return dynamic_cast<Invoker<F>>(_invoker_base())?
      std::launder(reinterpret_cast<F const*>(&_storage)) : nullptr;
  }
  template <typename F>
  F* target() {
    return const_cast<F*>(std::as_const(*this).template target<F>());
  }

  std::type_info const& target_type() const noexcept {
    _invoker_base()->type();
  }

  bool empty() const noexcept {
    return _empty;
  }

  operator bool() const noexcept {
    return !empty();
  }

  ~Function() {
    _clear();
  }

  Function() noexcept = default;
  Function(std::nullptr_t) noexcept {}

  Function(Function&& other) : _empty(other.empty()) {
    if (!empty())
      other._invoker_base()->move(&other._storage, &_storage, &_invoker_storage);
  }

  Function(Function const& other) : _empty(other.empty()) {
    if (!empty())
      other._invoker_base().copy(&other._storage, &_storage, &_invoker_storage);
  }

  template <typename F,
            typename = std::enable_if_t<_participate<F>>>
  Function(F&& f) : _empty(false) {
    _emplace(std::forward<F>(f));
  }

  Function& operator=(Function const& other) {
    _clear();
    _empty = other.empty();
    if (!empty())
      other._invoker_base().copy(&other._storage, &_storage, &_invoker_storage);
    return *this;
  }

  Function& operator=(Function&& other) {
    _clear();
    _empty = other.empty();
    if (!empty())
      other._invoker_base().move(&other._storage, &_storage, &_invoker_storage);
    return *this;
  }

  Function& operator=(std::nullptr_t) {
    _clear();
    return *this;
  }

  template <typename F,
            typename = std::enable_if_t<_participate<F>>>
  Function& operator=(F&& f) {
    _clear();
    _emplace(std::forward<F>(f));
    return *this;
  }

  template <typename F>
  Function& operator=(std::reference_wrapper<F> f) {
    _clear();
    _emplace(f.get());
    return *this;
  }

  void swap(Function& other) {
    std::swap(*this, other); // Best that can be done.
  }

  R operator()(Args... args) const {
    return _invoker_base()(&_storage, std::forward<Args>(args)...);
  }
};

template <typename R, typename... Args, std::size_t N>
bool operator==(Function<R(Args...), N> const& f, std::nullptr_t) noexcept {
  return !f;; }
template <typename R, typename... Args, std::size_t N>
bool operator==(std::nullptr_t, Function<R(Args...), N> const& f) noexcept {
  return !f; }
template <typename R, typename... Args, std::size_t N>
bool operator!=(Function<R(Args...), N> const& f, std::nullptr_t) noexcept {
  return f; }
template <typename R, typename... Args, std::size_t N>
bool operator!=(std::nullptr_t, Function<R(Args...), N> const& f) noexcept {
  return f; }

template <typename R, typename... Args, std::size_t N>
void swap(Function<R(Args...), N> &lhs, Function<R(Args...), N> &rhs) {
  lhs.swap(rhs);
}

#include <iostream>
int main() {
  Function<int(int), 16> f([] (int i) {return i*i;});
  auto g = f;
  g = f;
  std::cout << g(5);
  std::cout << "\nSize of Function: " << sizeof(f);
}

    Jetzt haben wir bei 16 Byte payload 32 Byte Function . Viel besser wird's nicht.

    0
    L
     1 Antwort
  • Mod

    Das Problem war schnell gefunden. Anscheinend ist die Standardausrichtung von aligned_storage 32? Invoker braucht nur 16. Damit haben wir 32 Byte.

    0
  • F

    @Arcoth

    Ich muss zugeben das ich nicht viel von dem Code verstehe, insbesondere nicht wozu man den braucht.

    Für mich ist er außerdem nicht nutzbar, da ein dynamic_cast benutzt wird und der eine Exception werfen kann, welche auf meinem Embedded System auch nicht zur Verfügung stehen.

    Mich würde allerdings interessieren, welchen Vorteil deine Version bietet?

    0
  • W

    FlashBurn schrieb:

    Für mich ist er außerdem nicht nutzbar, da ein dynamic_cast benutzt wird und der eine Exception werfen kann

    Aus Interesse: in welchen Fällen kann denn dynamic_cast Exceptions werfen?

    0
  • Mod

    FlashBurn schrieb:

    Ich muss zugeben das ich nicht viel von dem Code verstehe, insbesondere nicht wozu man den braucht.

    Ich habe doch deutlich geschrieben, dass diese Implementierung den Overhead durch new vermeidet indem sie alle Objekte im Function Objekt konstruiert. ➡

    Allerdings läuft der finale Code auf einem Embedded System und daher möchte/muss ich auf new verzichten und das ist bei std::bind ja nicht sicher gestellt.

    Für mich ist er außerdem nicht nutzbar, da ein dynamic_cast benutzt wird und der eine Exception werfen kann, welche auf meinem Embedded System auch nicht zur Verfügung stehen.

    1. dynamic_cast hat ausschließlich das Potenzial zu werfen, wenn man zu einem Referenztyp konvertiert. Das ist hier nicht der Fall. 2. dynamic_cast ist nicht für das Aufrufen des targets nötig, du kannst dieses Feature auch komplett weglassen wenn du möchtest.
    0
  • K

    Hi!

    Ich habe mich auch mal dran versucht und damit den GCC 7.2 zum Absturz gebracht. Aber Clang 5 hat's geschafft. Es geht in Richtung "fast delegates", aber implementiert mit den neuen auto-Template-Parameter. 🕶

    Nachteile:

    • Unterstützt nur freie Funktionen und Objektmethoden

    Vorteile:

    • Kein new
    • Sehr klein (immer zwei Zeiger groß)
    • Der Compiler kann das gut optimieren

    Der Beispiel-Code sieht so aus:

    // Magische Definition von function<> und fun<> hier.

#include <iostream>

static void hello() {
	std::cout << "Hello!\n";
}

struct strukt {
	int member;
	void increment() { member += 1; }
	void show() const { std::cout << member << '\n'; }
};

int main() {
	strukt s = { 42 };
	function<void()> f = fun<&hello>();
	f();
	f = fun<&strukt::increment>(&s);
	f();
	f();
	f();
	f = fun<&strukt::show>(&s);
	f();
	return 0;
}

    Hier ist der komplette Code. Das bekommt der Compiler auch krass optimiert: Es wird alles ge-inline-t.

    0
  • M

    FlashBurn schrieb:

    @Meep Meep

    Wenn ich deinen Code nicht vollständig falsch verstanden habe, dann kann er aber nur einen Empfänger benachrichtigen!?

    nunja, in dem fall hat er bzw. ist es ein slot.

    du kannst ja ueber eine registrierungsfunktion mehrere signalobjekte in einen vector oder sonst wo reinstopfen. wenn dann das bestimmte event auftritt, dann gehst du einfach die liste durch und rufst alle auf.

    0
  • L

    @Columbo Ich bin zufällig über Deinen Code gestolpert. Sowas hatte ich schon länger für Anwendungen in kleinen Microcontrollern gesucht. Ich habe, nach einigen Anpassungen für c++11 toolchains, daraus eine kleine Arduino "Library" gemacht und würde die gerne auf gitHub stellen (Draft hier: https://github.com/luni64/staticFunctional) wenn Du nichts dagegen hast.

    Lizenz: MIT
    Ich würde dich als Author natürlich erwähnen.

    Passt das für Dich?

    0
  • Mod

    @luni64 Einverstanden.

    0
Anmelden zum Antworten