使用函数作为回调时，有没有办法避免存储开销？

Question

鉴于以下设置：

// ***** Library Code *****
#include <concepts>

template <std::invocable CbT>
struct delegated {
  explicit constexpr delegated(CbT cb) : cb_(std::move(cb)) {}

 private:
  [[no_unique_address]] CbT cb_;
};

// ***** User Code *****
#include <iostream>

namespace {
  inline constexpr void func() {}
}

struct MyFunc {
  constexpr void operator()() const {}
};


int main() {
    void (*func_ptr)() = func;

    auto from_func = delegated{func};
    auto from_func_ptr = delegated{func_ptr};
    auto from_lambda = delegated{[](){}};
    auto from_functor = delegated{MyFunc{}};

    std::cout << "func: " << sizeof(from_func) << "\n";
    std::cout << "func_ptr: " << sizeof(from_func_ptr) << "\n";
    std::cout << "lambda: " << sizeof(from_lambda) << "\n";
    std::cout << "functor: " << sizeof(from_functor) << "\n";
}

它在 GCC-x86-64 (See on godbolt) 上产生：

func: 8        <----- Unfortunate
func_ptr: 8    <----- Fair enough
lambda: 1      <----- Neat
functor: 1     <----- Neat

这些都不是特别令人惊讶的。

但是，令人沮丧的是，未衰减的 lambda 比使用函数更可取。并且添加注释 delegated{[]{func();}} 减少存储开销并不完全是用户友好的，并且导致库界面非常糟糕。

有没有办法消除func 情况下的存储开销，同时保持面向用户的 API 一致？

我目前的怀疑是，如果不求助于宏，这是不可能的，因为func 没有或衰减为任何可以将其与具有相同签名的其他函数区分开来的类型。我希望我忽略了一些东西。

NB我知道类似delegated<func>() 的东西是有可能的，但除非我可以阻止delegated{func} 同时仍然允许delegated{func_ptr}，否则这实际上毫无意义。

编辑：稍微澄清一下上下文：我在图书馆写delegated，我不希望该图书馆的用户担心这一点。或者至少让该过程由编译器辅助，而不是依赖于文档。

Answer 1

没有函数类型的对象。类型将被调整为函数指针，这就是为什么你delegated{func}和delegated{func_ptr}完全一样，前者不能更小。

将函数调用封装在一个函数对象（lambda，如果你愿意的话）中，以避免函数指针的开销。

---

如果您想防止在用户尝试传递函数时意外使用调整/衰减函数指针的情况，那么您可以对函数引用使用已删除的重载。我不知道用CTAD怎么实现，但是如果你提供一个函数接口，它可以这样完成：

constexpr auto
make_delegated(std::invocable auto CbT)
{
    return delegated{std::move(CbT)};
}

template<class... Args>
constexpr auto
make_delegated(auto (&cb)(Args...)) = delete;

---

编辑：将想法与Human-Compiler's answer结合

template <auto CbT>
constexpr auto
make_delegated_fun() { 
  return delegated{ []{ CbT(); } };
}

constexpr auto
make_delegated(std::invocable auto CbT)
{
    return delegated{std::move(CbT)};
}

template<class... Args>
constexpr auto
make_delegated(auto (&cb)(Args...)) {
    // condition has to depend on template argument;
    // just false would cause the assert to trigger without overload being called.
    static_assert(!std::is_reference_v<decltype(cb)>, "please use make_delegated_fun");
};


auto from_func1 = make_delegated(func);        // fails to compile
auto from_func2 = make_delegated_fun<func>();  // OK
auto from_func_ptr = make_delegated(func_ptr); // OK, pointer overhead
auto from_lambda = make_delegated([](){});     // OK
auto from_functor = make_delegated(MyFunc{});  // OK

注意，这会阻止跟随，并且使用make_delegated_fun 的示例也不起作用，因此该消息会产生误导。该示例可以很容易地重写为使用函数指针或捕获 lambda：

auto& fun_ref = condition ? fun1 : fun2;
make_delegated(fun_ref);       // fails to compile, suggests make_delegated_fun
make_delegated_fun<fun_ref>(); // fails to compile, not constexpr
make_delegated(&fun_ref);      // OK, pointer overhead

Answer 2

真正从这样的函数中删除“存储”的唯一方法是在编译时使用该值。实现这一点的唯一真正方法是通过非类型模板参数。

工厂函数只需稍作改动即可轻松完成此操作，并保持实现简单。您只需要接受可调用对象作为模板非类型参数——例如auto 参数，以便在编译时知道它而无需任何存储要求。

执行此操作的一种方法是将您的 lambda 包装解决方案与现有代码一起使用：

template <auto Fn>
auto make_delegated() { 
  return delegated{ []{ Fn(); } };
}

然后以下工作：

auto from_func = make_delegated<&func>();
std::cout << "func: " << sizeof(from_func) << "\n";

这会产生正确的值：

func: 1

Live Example

---

作为替代措施，您还可以要求用户将函数本身包装在携带数据的哨兵类型中：

template <auto Fn>
struct empty_func{
  auto operator()() { return Fn(); }
};

这几乎等同于使用 lambda，尽管用户只需要这样做：

auto from_func = delegated{empty_func<&func>{}};

关键是函数需要在编译时的某个地方携带。

Answer 3

将函数指针作为模板参数传递在运行时不需要任何空间。例如：

template <auto F>
struct delegated_erased {
    template <typename... argument_t>
    auto operator()(argument_t&&... argument){
        F(std::forward<argument_t>(argument)...);
    }
};

auto from_func = delegated_erased<func>{};
std::cout << "func: " << sizeof(from_func) << "\n"; // 1

借助辅助函数，您可以将其与您的代码结合使用：

template <typename result, typename ... argument>
delegated<result> make_delegated(result(&)(argument...)) = delete;

template <typename T>
delegated<T> make_delegated(T f) {
    return delegated{std::move(f)};
};

template <auto F>
delegated_erased<F> make_delegated(){
    return {};
}

您可以这样做：

    auto from_func = make_delegated<func>();
    //auto from_func = make_delegated(func); // error: call to deleted function 'make_delegated'
    auto from_func_ptr = make_delegated(func_ptr);
    auto from_lambda = make_delegated([](){});
    auto from_functor = make_delegated(MyFunc{});