模板、decltype 和非类类型

Question

我有一个这样的函数定义

template <typename T>
auto print(T t) -> decltype(t.print()) {
    return t.print();
}

想法是参数必须是T 类型并且必须具有print 函数。这个print 函数可以返回任何东西，解释了decltype 的需要。所以例如你可以这样做：

struct Foo
{
    int print()
    {
        return 42;
    }
};

struct Bar
{
    std::string print()
    {
        return "The answer...";
    }
};

...

std::cout << print(Foo()) << std::endl;    
std::cout << print(Bar()) << std::endl;
/* outputs: 
42
The answer...
*/

我读到模板不能进行运行时实例化，您可以让类派生自基类，然后确定它们的类型以查看要使用的模板参数。但是，我将如何为 non-class 类型执行此操作？我们的想法是能够：

template <typename T>
T print(T t) {
    return t;
}

也是如此，但这给了我模棱两可的过载错误。排位赛不起作用，即print<Foo>。另一个问题是，如果我有一个函子会怎样：

struct Foo
{
  virtual int print();
  operator int() const
  {
    return 42;
  }
};

它现在如何决定？

所以我的问题是，是否有可能用模板解决所有这些歧义，还是我必须编写一堆冗余代码？

测试

我逐渐添加了测试，从下面复制/粘贴每个已编辑的解决方案。结果如下：

具有以下类：

struct Foo
{
    int print()
    {
        return 42;
    }

    operator int() const
    {
        return 32;
    }
};

struct Bar
{
    std::string print()
    {
        return "The answer...";
    }

    operator int() const
    {
        return (int)Foo();
    }
};

struct Baz
{
    operator std::string() const
    {
        return std::string("The answer...");
    }
};

以及以下测试输出：

std::cout << print(Foo()) << std::endl;    
std::cout << print(Bar()) << std::endl;
std::cout << print(42) << std::endl;
std::cout << print((int)Foo()) << std::endl;
std::cout << print("The answer...") << std::endl;
std::cout << print(std::string("The answer...")) << std::endl;
std::cout << print((int)Bar()) << std::endl;
std::cout << print((std::string)Baz()) << std::endl;

都正确输出：

42
The answer...
42
32
The answer...
The answer...
32
The answer...

Answer 1

您可以采用以下方法，如果存在print()成员函数，则在输入上调用该成员函数，否则将返回输入本身：

namespace detail
{
    template<typename T, typename = void>
    struct print_helper
    {
        static T print(T t) {
            return t;
        }
    };

    template<typename T>
    struct print_helper<T, decltype(std::declval<T>().print(), (void)0)>
    {
        static auto print(T t) -> decltype(t.print()) {
            return t.print();
        }
    };
}

template<typename T>
auto print(T t) -> decltype(detail::print_helper<T>::print(t))
{
    return detail::print_helper<T>::print(t);
}

这是live example。

Answer 2

使用手动重载为您要打印的每种类型的简单解决方案直接：

定义你的第一个实现，它调用T::print()。使用重载为所有没有此功能的类型指定替代实现。我不推荐这种解决方案，但它很容易理解。

template<typename T>
auto print(T t) -> decltype(t.print()) {
    return t.print();
}

int print(int t) {
    return t;
}
std::string print(std::string t) {
    return t;
}
// ... and so on, for each type you want to support ...

---

使用 SFINAE 的更高级解决方案，当且仅当 T::print() 存在时自动使用它：

首先，定义一个特征，它可以决定你的类型是否有函数print()。基本上，这个特征继承自 std::true_type 或 std::false_type，这取决于在某个帮助程序类 (_test_print) 中做出的决定。然后，在enable_if 编译时决策中使用此类型特征，该决策只定义了两种情况中的一种，并隐藏了另一种情况（所以这不是重载）。

// Type trait "has_print" which checks if T::print() is available:
struct _test_print {
    template<class T> static auto test(T* p) -> decltype(p->print(), std::true_type());
    template<class>   static auto test(...)  -> std::false_type;
};
template<class T> struct has_print : public decltype(_test_print::test<T>(0)) {};


// Definition of print(T) if T has T::print():
template<typename T>
auto print(T t) -> typename std::enable_if<has_print<T>::value, decltype(t.print())>::type {
    return t.print();
}

// Definition of print(T) if T doesn't have T::print():
template<typename T>
auto print(T t) -> typename std::enable_if<!has_print<T>::value, T>::type {
    return t;
}

看看live demo。