移动

Question

我正在基于发布/订阅模式在C ++ 11中开发一个简单的事件驱动的应用程序。类具有由事件循环（控制反转）调用的一个或多个onWhateverEvent()方法。由于应用程序实际上是一个固件，其中代码大小至关重要且灵活性不是高优先级，因此订阅＆＃39; part是一个包含事件ID和关联处理程序的简单表。

这是一个非常简化的想法代码：

#include <functional>

enum Events {
    EV_TIMER_TICK,
    EV_BUTTON_PRESSED
};

struct Button {
    void onTick(int event) { /* publish EV_BUTTON_PRESSED */ }
};

struct Menu {
    void onButtonPressed(int event) { /* publish EV_SOMETHING_ELSE */ }
};

Button button1;
Button button2;
Menu mainMenu;

std::pair<int, std::function<void(int)>> dispatchTable[] = {
    {EV_TIMER_TICK, std::bind(&Button::onTick, &button1, std::placeholders::_1) },
    {EV_TIMER_TICK, std::bind(&Button::onTick, &button2, std::placeholders::_1) },
    {EV_BUTTON_PRESSED, std::bind(&Menu::onButtonPressed, &mainMenu, std::placeholders::_1) }
};

int main(void) 
{
    while(1) {
        int event = EV_TIMER_TICK; // msgQueue.getEventBlocking();
        for (auto& a : dispatchTable) {
            if (event == a.first) 
                a.second(event);
        }
    }
}

使用桌面编译器编译并运行良好，std:function<void(int)>> fn = std::bind(&SomeClass::onSomething), &someInstance, std::placeholders::_1)优雅地实现类型擦除，因此事件调度表可以保存不同类的处理程序，因此不同类型。

问题来自支持C ++ 11的嵌入式编译器（AVR-GCC 4.8.3），但是没有标准C ++库：没有<functional>标头。我在想如何只使用编译器功能重新创建上述行为。我评估了一些选项，但每个选项（由编译器或我）都有异议：

使用virtual void Handler::onEvent(int event)方法创建界面，并从中派生Button和Menu。调度表可以保存接口指针，其余的是虚方法调用。这是最简单的方法，但我不喜欢将事件处理程序方法的数量限制为每个类一个（使用本地if-else事件调度），并且每个事件都有虚拟方法调用的开销。
我的第二个想法仍然包含虚拟方法调用，但对Button和Menu类没有限制。它是一个基于虚方法调用的类型擦除函数：
```
struct FunctBase {
    virtual void operator()(int event) = 0;
};

template<typename T>
struct Funct : public FunctBase
{
    T* pobj;                 //instance ptr
    void (T::*pmfn)(int);    //mem fun ptr
    Funct(T* pobj_, void (T::*pmfn_)(int)) : pobj(pobj_), pmfn(pmfn_) {}

    void operator()(int ev) override {
        (pobj->*pmfn)(ev);
    }
};
```
Funct可以包含实例和方法指针，而调度表可以由FunctBase指针构成。这种方式与使用function / bind一样灵活：可以为每个类保存任何类（类型）和任意数量的处理程序。我唯一的问题是它每个事件仍然包含1个虚拟方法调用，它只是移动到了仿函数。
我的第三个想法是一个简单的黑客转换方法指向函数指针：
```
typedef void (*Pfn)(void*, int);
Pfn pfn1 = reinterpret_cast<Pfn>(&Button::onTick);
Pfn pfn2 = reinterpret_cast<Pfn>(&Menu::onButtonPressed);
```
据我所知，这是Undefined Behavior，确实让编译器发出了很大的警告。它基于c ++方法具有指向this的隐式1st参数的假设。尽管如此，它很有用，它很轻巧（没有虚拟电话），而且非常灵活。

所以我的问题：是否有可能以干净的C ++方式执行类似选项3的操作？我知道有一种基于void *的类型擦除技术（与选项2中的虚方法调用相反），但我不知道如何实现它。使用std :: bind查看桌面版本也给我的印象是它将第一个隐式参数绑定为实例指针，但可能只是语法。

Answer 1

坚固，高效，std::function<R(Args...)>替换并不难写。

当我们嵌入时，我们希望避免分配内存。所以我写了small_task< Signature, size_t sz, size_t algn >。它创建了一个大小为sz且对齐algn的缓冲区，用于存储其已擦除的对象。

它还存储了一个移动器，一个驱逐舰和一个调用函数指针。这些指针可以位于small_task（最大位置）的本地范围内，也可以位于手册struct vtable { /*...*/ } const* table内。

template<class Sig, size_t sz, size_t algn>
struct small_task;

template<class R, class...Args, size_t sz, size_t algn>
struct small_task<R(Args...), sz, algn>{
  struct vtable_t {
    void(*mover)(void* src, void* dest);
    void(*destroyer)(void*);
    R(*invoke)(void const* t, Args&&...args);
    template<class T>
    static vtable_t const* get() {
      static const vtable_t table = {
        [](void* src, void*dest) {
          new(dest) T(std::move(*static_cast<T*>(src)));
        },
        [](void* t){ static_cast<T*>(t)->~T(); },
        [](void const* t, Args&&...args)->R {
          return (*static_cast<T const*>(t))(std::forward<Args>(args)...);
        }
      };
      return &table;
    }
  };
  vtable_t const* table = nullptr;
  std::aligned_storage_t<sz, algn> data;
  template<class F,
    class dF=std::decay_t<F>,
    // don't use this ctor on own type:
    std::enable_if_t<!std::is_same<dF, small_task>{}>* = nullptr,
    // use this ctor only if the call is legal:
    std::enable_if_t<std::is_convertible<
      std::result_of_t<dF const&(Args...)>, R
    >{}>* = nullptr
  >
  small_task( F&& f ):
    table( vtable_t::template get<dF>() )
  {
    // a higher quality small_task would handle null function pointers
    // and other "nullable" callables, and construct as a null small_task

    static_assert( sizeof(dF) <= sz, "object too large" );
    static_assert( alignof(dF) <= algn, "object too aligned" );
    new(&data) dF(std::forward<F>(f));
  }
  // I find this overload to be useful, as it forces some
  // functions to resolve their overloads nicely:
  // small_task( R(*)(Args...) )
  ~small_task() {
    if (table)
      table->destroyer(&data);
  }
  small_task(small_task&& o):
    table(o.table)
  {
    if (table)
      table->mover(&o.data, &data);
  }
  small_task(){}
  small_task& operator=(small_task&& o){
    // this is a bit rude and not very exception safe
    // you can do better:
    this->~small_task();
    new(this) small_task( std::move(o) );
    return *this;
  }
  explicit operator bool()const{return table;}
  R operator()(Args...args)const{
    return table->invoke(&data, std::forward<Args>(args)...);
  }
};

template<class Sig>
using task = small_task<Sig, sizeof(void*)*4, alignof(void*) >;

live example

缺少的另一件事是高质量void(Args...)，如果传入的可调用值具有返回值，则不关心。

上述任务支持移动，但不支持复制。添加副本意味着存储的所有内容都必须是可复制的，并且需要vtable中的其他功能（实现类似于move，除了src是const而没有std::move）。

使用了少量的C ++ 14，即enable_if_t和decay_t别名等。它们可以用C ++ 11轻松编写，或者用typename std::enable_if<?>::type替换。

老实说，

bind最好用lambdas取代。即使在非嵌入式系统上，我也不会使用它。

另一个改进是教它如何通过存储它们的small_task指针来处理更小/更少对齐的vtable，而不是将它复制到data缓冲区，并包装它在另一个vtable。这样可以鼓励使用small_tasks，这对于您的问题集来说只是勉强够用。

将成员函数转换为函数指针不仅是未定义的行为，通常函数的调用约定与成员函数不同。特别是，this在某些调用约定下的特定寄存器中传递。

这种差异可能很微妙，当您更改不相关的代码或编译器版本更改时，或其他任何内容都会出现。所以除非你别无选择，否则我会避免这种情况。

如上所述，该平台缺乏图书馆。上面std的每次使用都很小，所以我只会写下来：

template<class T>struct tag{using type=T;};
template<class Tag>using type_t=typename Tag::type;
using size_t=decltype(sizeof(int));

移动

template<class T>
T&& move(T&t){return static_cast<T&&>(t);}

向前

template<class T>
struct remove_reference:tag<T>{};
template<class T>
struct remove_reference<T&>:tag<T>{};
template<class T>using remove_reference_t=type_t<remove_reference<T>>;

template<class T>
T&& forward( remove_reference_t<T>& t ) {
  return static_cast<T&&>(t);
}
template<class T>
T&& forward( remove_reference_t<T>&& t ) {
  return static_cast<T&&>(t);
}

衰变

template<class T>
struct remove_const:tag<T>{};
template<class T>
struct remove_const<T const>:tag<T>{};

template<class T>
struct remove_volatile:tag<T>{};
template<class T>
struct remove_volatile<T volatile>:tag<T>{};

template<class T>
struct remove_cv:remove_const<type_t<remove_volatile<T>>>{};


template<class T>
struct decay3:remove_cv<T>{};
template<class R, class...Args>
struct decay3<R(Args...)>:tag<R(*)(Args...)>{};
template<class T>
struct decay2:decay3<T>{};
template<class T, size_t N>
struct decay2<T[N]>:tag<T*>{};

template<class T>
struct decay:decay2<remove_reference_t<T>>{};

template<class T>
using decay_t=type_t<decay<T>>;

is_convertible

template<class T>
T declval(); // no implementation

template<class T, T t>
struct integral_constant{
  static constexpr T value=t;
  constexpr integral_constant() {};
  constexpr operator T()const{ return value; }
  constexpr T operator()()const{ return value; }
};
template<bool b>
using bool_t=integral_constant<bool, b>;
using true_type=bool_t<true>;
using false_type=bool_t<false>;

template<class...>struct voider:tag<void>{};
template<class...Ts>using void_t=type_t<voider<Ts...>>;

namespace details {
  template<template<class...>class Z, class, class...Ts>
  struct can_apply:false_type{};
  template<template<class...>class Z, class...Ts>
  struct can_apply<Z, void_t<Z<Ts...>>, Ts...>:true_type{};
}
template<template<class...>class Z, class...Ts>
using can_apply = details::can_apply<Z, void, Ts...>;

namespace details {
  template<class From, class To>
  using try_convert = decltype( To{declval<From>()} );
}
template<class From, class To>
struct is_convertible : can_apply< details::try_convert, From, To > {};
template<>
struct is_convertible<void,void>:true_type{};

enable_if

template<bool, class=void>
struct enable_if {};
template<class T>
struct enable_if<true, T>:tag<T>{};
template<bool b, class T=void>
using enable_if_t=type_t<enable_if<b,T>>;

的result_of

namespace details {
  template<class F, class...Args>
  using invoke_t = decltype( declval<F>()(declval<Args>()...) );

  template<class Sig,class=void>
  struct result_of {};
  template<class F, class...Args>
  struct result_of<F(Args...), void_t< invoke_t<F, Args...> > >:
    tag< invoke_t<F, Args...> >
  {};
}
template<class Sig>
using result_of = details::result_of<Sig>;
template<class Sig>
using result_of_t=type_t<result_of<Sig>>;

aligned_storage

template<size_t size, size_t align>
struct alignas(align) aligned_storage_t {
  char buff[size];
};

is_same

template<class A, class B>
struct is_same:false_type{};
template<class A>
struct is_same<A,A>:true_type{};

live example，我需要的每个std库模板大约有十几行。

我会把这个＆＃34; std库重新实现＆＃34;进入namespace notstd以明确发生了什么。

如果可以，请使用将相同功能折叠在一起的链接器，如黄金链接器。模板元编程可能会导致二进制膨胀而没有实体链接器来剥离它。

Answer 2

您的第一个想法是针对该问题的典型面向对象解决方案。它非常好，但有点笨拙 - 不像stream create --name dbtest --definition "time --fixedDelay=10 | jdbc --url='jdbc:sqlserver://localhost:54732;instanceName=1LLENSBROWN\SQLEXPRESS;databaseName=XMLTestDatabase;integratedSecurity=true;' --driverClassName=com.microsoft.sqlserver.jdbc.SQLServerDriver" --deploy那么可用。你的第三个想法是未定义的行为。不，不，不。

你的第二个想法 - 现在有了我们可以合作的东西！这与std::function实际实现的方式很接近。我们可以编写一个类，它可以使用std::function可调用的任何对象并返回int：

void

通过这种方式，您基本上可以使用class IntFunc { private: struct placeholder { virtual ~placeholder() = default; virtual void call(int ) = 0; }; template <typename F> struct holder : placeholder { holder(F f) : func(f) { } void call(int i) override { func(i); } F func; }; // if you wrote your own unique_ptr, use it here // otherwise, will have to add rule of 5 stuff placeholder* p; public: template <typename F> IntFunc(F f) : placeholder(new holder<F>(f)) { } template <typename Cls> IntFunc(Cls* instance, void (Cls::*method)(int )) { auto lambda = [=](int i){ (instance->*method)(i); }; placeholder = new holder<decltype(lambda)>(lambda); } void operator()(int i) { p->call(i); } };一种可用的通用方式。

现在第4个想法可能只是将你的第三个想法扩展到可用的东西。实际上使用函数指针：

std::function<void(int)>

然后使用lambdas制作这样的东西：

using Pfn = void (*)(void*, int);

但是你必须以某种方式坚持上下文 - 这会增加额外的工作。

Answer 3

在我尝试手工编写所有STL之前，我尝试使用编译器本身已有的STL。因为你使用的大多数STL代码只是标题，所以我只是包含它并做一些小的黑客来编译它们。事实上，id做了10分钟准备链接！

我使用了avr-gcc-5.2.0版本，没有任何问题。我没有旧安装，我相信在几分钟内安装实际版本更容易，而不是修复旧版本的问题。

编译avr的示例代码后，我收到链接错误：

build-check-std-a520-nomemdbg-os-dynamic-noncov/main.o: In function `std::__throw_bad_function_call()':
/home/krud/own_components/avr_stl/avr_stl009/testing/main.cpp:42: undefined reference to `operator delete(void*, unsigned int)'
/home/krud/own_components/avr_stl/avr_stl009/testing/main.cpp:42: undefined reference to `operator delete(void*, unsigned int)'
collect2: error: ld returned 1 exit status

只需编写自己的__throw_bad_function_call并解决链接问题。

对我来说，编写自己的STL实现是没有意义的。在这里，我只使用了来自编译器安装（gcc 5.2.0）的标题。

std :: function / bind就像没有标准C ++库的type-erasure一样

3 个答案:

移动

向前

衰变

is_convertible

enable_if

的result_of

aligned_storage

is_same