c++ - 根据模板参数的模板函数名称

Question

我一直在寻找与我的问题相关的示例，但我仍然找不到解决方案。我发现的最接近的是

Template function as a template argument

我会尝试发布一个工作示例以备不时之需，但到目前为止我的部分代码涉及以下:

template<class InterfaceType, class T> 
inline void write_info(InterfaceType& interface, T& t) {
    InterfaceType::write_info(interface, t);
}

template<class InterfaceType, class T> 
inline void write_data(InterfaceType& interface, T& t) {
    InterfaceType::write_data(interface, t);
}

template<class InterfaceType, class T> 
inline void write_definition(InterfaceType& interface, T& t) {
    InterfaceType::write_definition(interface, t);
}

请注意模板write_info 依赖于一个接口(interface)类型，该接口(interface)类型有一个名为write_info 的方法(静态方法)。这样做的原因是因为 write_info 函数可以稍后专门用于特定数据类型，而无需在 InterfaceType 上重新定义任何内容。

简单的问题是:我们可以用一个将函数命名为函数参数的模板来减少上面的代码吗？请记住，我真的希望这成为可能，这样我就可以避免为专门的数据类型定义所有这 3 个函数，即

假设foo 是一个具有两个属性int a 和double b 的结构。然后我可以像这样专门化上述功能:

template<class InterfaceType> 
inline void write_info(InterfaceType& interface, foo& t) {
    InterfaceType::write_info(interface, t.a);
    InterfaceType::write_info(interface, t.b);
}

template<class InterfaceType> 
inline void write_data(InterfaceType& interface, foo& t) {
    InterfaceType::write_data(interface, t.a);
    InterfaceType::write_data(interface, t.b);
}

template<class InterfaceType> 
inline void write_definition(InterfaceType& interface, foo& t) {
    InterfaceType::write_definition(interface, t.a);
    InterfaceType::write_definition(interface, t.b);
}

如您所见，我一遍又一遍地编写相同的代码。在这里，我假设 InterfaceType 已经为 int 和 定义了 write_info、write_data 和 write_definition双。有什么想法吗？

Answer 1

扭转逻辑:与其为每种类型编写专门的 write_thing 重载，不如编写一个 apply 函数，将任意函数应用于每种类型的对象，然后每个 write_thing 都有一个重载，它只是委托(delegate)给 apply:

// Define a catch-all apply that handles "everything else"
template <typename Interface, typename Function, typename Object>
void apply(Interface& i, Function f, Object& x) {
    f(i, x);
}

// Define overloads for "apply" that handle special cases
template <typename Interface, typename Function>
void apply(Interface& i, Function f, foo& x) {
    f(i, x.a);
    f(i, x.b);
}

// Define polymorphic adapters for your write_[thing] functions:
struct write_info_impl {
    template <typename Interface, typename Object>
    void operator()(Interface& i, Object& x) const {
        Interface::write_info(i, x);
    }
};

// Then implement your write_[thing] functions in terms of the above:
template <typename Interface, typename Object>
void write_info(Interface& interface, Object& x) {
    apply(i, write_info_impl(), x);
}