模板函子到特定函子的显式转换

问题描述

我有一个可调用的结构 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 的某种“静态转换”，它具有 no与简单调用成员函数相比的计算开销。也可以采用 CRTP 解决方案，但它可能会为我希望更简单的事情添加太多样板代码。 实现上述目标的最有效方法是什么？

解决方法

您认为涉及额外开销的假设不一定正确。编译器确实擅长优化事物，并且在花时间重构代码以确保没有任何好处之前，总是值得确认是否是这种情况。

举个例子：

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

c++callable-object crtp functor templates templates templates