从模板检查成员函数重载是否存在

Question

是否可以从模板成员函数中检查 class 是否有某个成员函数重载？

我能找到的最相似的问题是这个：Is it possible to write a template to check for a function's existence?据我了解，这不适用于检查函数重载的情况。

这里有一个简单的应用示例：

struct A;
struct B;

class C
{
public:
    template<typename T>
    void doSomething(std::string asdf)
    {
        T data_structure;

        /** some code */

        if(OVERLOAD_EXISTS(manipulateStruct, T))
        {
            manipulateStruct(data_structure);
        }

        /** some more code */
    }

private:
    void manipulateStruct(B& b) {/** some different code */};
}

我的问题是是否存在某种标准方法可以使代码的以下用法起作用：

int main(int argc, const char** argv)
{
    C object;
    object.doSomething<A>("hello");
    object.doSomething<B>("world");
    exit(0);
}

我能想到的唯一方法是简单地为结构 A 创建一个 manipulateStruct 的空重载。否则操作方法当然也可以放入要操作的结构中，这将使 SFINAE 成为一个选项。让我们假设这两种情况都不可能发生。

有什么方法可以使类似于上述代码的代码起作用吗？是否存在类似于 OVERLOAD_EXISTS 的东西，让编译器知道何时将 manipulateStruct 部分添加到生成的代码中？或者是否有一些聪明的方法可以让 SFINAE 为这种情况工作？

Answer 1

测试是否存在重载 (C++11)

自 C++11 起，您可以混合使用 std::declval and decltype 来测试特定重载的存在：

// If overload exists, gets its return type.
// Else compiler error
decltype(std::declval<C&>().manipulateStruct(std::declval<T&>()))

这可以用在 SFINAE 结构中：

class C {
public:
    // implementation skipped
private:
    // Declared inside class C to access its private member.
    // Enable is just a fake argument to do SFINAE in specializations.
    template<typename T, typename Enable=void>
    struct can_manipulate;
}

template<typename T, typename Enable>
struct C::can_manipulate : std::false_type {};

// Implemented outside class C, because a complete definition of C is needed for the declval.
template<typename T>
struct C::can_manipulate<T,std::void_t<decltype(std::declval<C&>().manipulateStruct(std::declval<T&>()))>> : std::true_type {};

这里我忽略了return类型的重载使用std::void_t (C++17, but C++11 alternatives should be possible). If you want to check the return type, you can pass it to std::is_same or std::is_assignable。

doSomething 实施

C++17

这可以用constexpr if来完成：

template<typename T>
void doSomething(std::string asdf) {
    T data_structure;
    if constexpr (can_manipulate<T>::value) {
        manipulateStruct(data_structure);
    }
}

如果条件计算为假，if constexpr 将使编译器丢弃 statement-true。如果没有 constexpr，编译将要求 if 中的函数调用在所有情况下都有效。

Live demo (C++17 full code)

C++11

您可以使用 SFINAE 模拟 if constexpr 行为：

class C {
    // previous implementation
private:
    template<typename T, typename Enable=void>
    struct manipulator;
}

template<typename T, typename Enable>
struct C::manipulator {
    static void call(C&, T&) {
        //no-op
    }
};

// can_manipulate can be inlined and removed from the code
template<typename T>
struct C::manipulator<T, typename std::enable_if<C::can_manipulate<T>::value>::type> {
    static void call(C& object, T& local) {
        object.manipulateStruct(local);
    }
};

函数体：

template<typename T>
T doSomething()
{
    T data_structure;
    // replace if-constexpr:
    manipulator<T>::call(*this, data_structure);
}

Live demo (C++11 full code)

从模板检查成员函数重载是否存在

Checking member function overload existence from a template

c++

templates

sfinae

测试是否存在重载 (C++11)

doSomething 实施

C++17

C++11