“模拟”偏函数模板特化？

Question

我知道部分模板特化不适用于函数。 但是有什么方法可以实现类似的目标吗？ 我的用例非常简单，但我不确定解决它的最佳方法是什么。

假设我正在编写一个接收 STL 容器的函数：

template<typename T>
void doSomething(T& container) {
    // do something here
}

现在，当std::forward_list和std::list被传std::forward_list ，我想要这个函数的不同定义。

起初我想也许我可以像这样重载函数：

// overload for std::list
template<typename T>
void insertionCppStl(std::list<T>& container) {
    // do seomthing here for list
}

但这意味着我也需要对std::forward_list执行相同的重载。 这一点都不理想。

有没有办法为两种不同的输入类型重载一个函数？ 寻找 C++17 的答案，但也欢迎 C++20 的答案。

Answer 1

不是一个很好的解决方案，但是......

template <template <typename...> class C, typename T>
std::enable_if_t<std::is_same_v<C<T>, std::list<T>>
              || std::is_same_v<C<T>, std::forward_list<T>>>
    insertionCppStl (C<T> & container) {
    // do seomthing here for list
}

（注意：代码未经测试）

正如 Daniel Langr 所指出的（谢谢！）这仅适用于具有标准分配器的列表，因此对于std::list<T>和std::forward_list<T> ，不适用于std::list<T, A>和std::forward_list<T, A>其中A是不同于std::allocator<T> 。

这对您来说是否足够，取决于您的需要。

一个更通用的解决方案也可以考虑分配器

template <template <typename...> class C, typename T, typename A>
std::enable_if_t<std::is_same_v<C<T, A>, std::list<T, A>>
              || std::is_same_v<C<T, A>, std::forward_list<T, A>>>
    insertionCppStl (C<T, A> & container) {
    // do seomthing here for list
}

显然这仅适用于std::list和std::forward_list 。

正如 Barry 在评论中指出的（谢谢！），当您有两个（三个、四个……）类型具有共同点（在这种情况下：具有兼容签名的模板类型）但不是一个一般解决方案。

不幸的是，我没有看到一个简单的通用解决方案......我建议开发一个特定的 type_traits 来为函数的特定版本选择可接受的类型。

例如：如果您想要std::list s、 std::forward_list s 和std::array s 的特定版本，您可以编写如下内容

template <typename>
struct specific_foo : public std::false_type
 { };

template <typename T, typename A>
struct specific_foo<std::list<T, A>> : public std::true_type
 { };

template <typename T, typename A>
struct specific_foo<std::forward_list<T, A>> : public std::true_type
 { };

template <typename T, std::size_t N>
struct specific_foo<std::array<T, N>> : public std::true_type
 { };

然后是foo()函数的两个版本：特定版本（接收std::true_type作为第二个参数）和通用版本（接收std::false_type

template <typename T>
void foo (T const &, std::false_type)
 { std::cout << "generic version" << std::endl; }

template <typename T>
void foo (T const &, std::true_type)
 { std::cout << "specific version" << std::endl; }

现在你需要一个标签调度版本的foo()来为第二个参数选择正确的类型

template <typename T>
void foo (T const & t)
 { foo(t, specific_foo<T>{}); }

下面是一个完整的编译示例

#include <list>
#include <array>
#include <vector>
#include <iostream>
#include <type_traits>
#include <forward_list>

template <typename>
struct specific_foo : public std::false_type
 { };

template <typename T, typename A>
struct specific_foo<std::list<T, A>> : public std::true_type
 { };

template <typename T, typename A>
struct specific_foo<std::forward_list<T, A>> : public std::true_type
 { };

template <typename T, std::size_t N>
struct specific_foo<std::array<T, N>> : public std::true_type
 { };

template <typename T>
void foo (T const &, std::false_type)
 { std::cout << "generic version" << std::endl; }

template <typename T>
void foo (T const &, std::true_type)
 { std::cout << "specific version" << std::endl; }

template <typename T>
void foo (T const & t)
 { foo(t, specific_foo<T>{}); }

int main ()
 {
   foo(0);                             // print "generic version"
   foo(std::list<int>{});              // print "specific version"
   foo(std::forward_list<long>{});     // print "specific version"
   foo(std::array<long long, 42u>{});  // print "specific version"
   foo(std::vector<char>{});           // print "generic version"
 }