#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<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*) >;

生活例子。

另一个缺失的东西是高质量的void(Args...)，它不关心传入的可调用对象是否有返回值。

以上任务支持移动，不支持复制。添加复制意味着存储的所有内容都必须是可复制的，并且需要在虚表中使用另一个函数(实现类似于move，除了src是const而不是std::move)。

使用了少量的c++ 14，即enable_if_t和decay_t别名以及类似的别名。它们可以很容易地用c++ 11编写，或者用typename std::enable_if<?>::type代替。

老实说，

bind最好用lambda代替。我甚至在非嵌入式系统上也不用它。

另一个改进是教它如何处理更小/更少对齐的small_task s，存储它们的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);
}

<标题>衰变h1> 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 h1> result_of h1> aligned_storage h1> is_same

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

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

我将把这个"std库重新实现"放入namespace notstd中，以清楚地说明发生了什么。

如果可以的话，使用链接器将相同的函数折叠在一起，就像黄金链接器一样。模板元编程可能会导致二进制文件膨胀，而没有一个可靠的链接器来剥离它。

你的第一个想法是典型的面向对象的问题解决方案。它非常好，但有点笨拙-不像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);
    }
};

这样，你基本上以一种可用的、通用的方式拥有了std::function<void(int)>。

现在，第四个想法可能只是扩展你的第三个想法到一些可用的东西。实际使用函数指针:

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

然后使用lambdas来做这样的事情:

Pfn buttonOnTick = [](void* ctxt, int i){
    static_cast<Button*>(ctxt)->onTick(i);
};

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

在我尝试手工编写所有STL内容之前，我尝试使用我已经从编译器本身获得的STL。因为您使用的大多数STL代码都只是头文件，所以我只是简单地包含它并做一些小的修改来编译它们。事实上，我花了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)中的头文件。