将模板化函子显式转换为特定函子

Question

我有一个可调用的结构 Foo 定义为

struct Foo {
    template <typename T>
    void operator()(T i) const { /* ... */ }
};

出于超出范围的原因，我想静态选择要调用它的类型，避免使用以下繁琐的符号：

Foo foo;
foo.operator()<int>(0);
foo.operator()<char>('0');
foo.operator()<char>(0);    // Notice: I want to select the implementation 
                            // so that **implicit conversions may take place**.

为此，我想实现一个模板成员函数To()，这样上面就可以改写为：

foo.To<int>()(0);
foo.To<char>()('0');
foo.To<char>()(0);

基本上，foo.To<T>() 将返回一个可用作回调的可调用对象。 一种方法可以通过使用 lambdas 来完成：

struct Foo {
    template <typename T>
    void operator()(T i) const { /* ... */ }

    template <typename T>
    auto To() const {
        return [this](T i) -> void {
            return this->operator()<T>(i);
        };
    }
};

但是，我不太喜欢这种解决方案，因为它会创建一个 lambda 并按值返回它，而我更希望有某种Foo 的“静态转换”没有计算开销与对成员函数的简单调用相比。也可以采用 CRTP 解决方案，但它可能会添加太多样板代码，而我希望这样做会更简单。 实现上述目标最有效的方法是什么？

Answer 1

您关于涉及额外开销的假设不一定正确。编译器真的擅长优化事物，在花时间重构代码之前总是值得确认是否是这种情况，因为这不会带来任何好处。

例子：

struct Foo {
    template <typename T>
    void operator()(T i) const;

    template <typename T>
    auto To() const {
        return [this](T i) -> void {
            return (*this)(i);
        };
    }
};

// Directly
void foo(const Foo& obj, char v) {
    return obj(v);
}

auto bar(const Foo& obj, int v) {
    return obj.To<char>()(v);
}

// As functors
auto get_foo_functor(const Foo& obj) {
  return obj;
}

auto get_To_functor(const Foo& obj) {
  return obj.To<char>();
}

Gcc 将其编译为

foo(Foo const&, char):
        movsx   esi, sil
        jmp     void Foo::operator()<char>(char) const
bar(Foo const&, int):
        movsx   esi, sil
        jmp     void Foo::operator()<char>(char) const
get_foo_functor(Foo const&):
        xor     eax, eax
        ret
get_To_functor(Foo const&):
        mov     rax, rdi
        ret

您可以在这里使用 Godbolt 上的示例：https://gcc.godbolt.org/z/jv6ejYn39