C++模板部分专业化 - 最专攻unique_ptr<t>

Question

我正在尝试创建部分专用的模板，如果通过std::unique_ptr，我会进一步专业化

template <typename T, typename = void>
struct Foo;
// A
template <typename T>
struct Foo<std::unique_ptr<T>, typename std::enable_if<std::is_class<T>::value>::type> {...};
// B
template <typename T>
struct Foo<T, typename std::enable_if<std::is_class<T>::value>::type> {...};
void fn() {
Foo<std::unique_ptr<T>> foo;
}

我的理解是，A比B更专业，应该是使用的那个。但至少在 MSVC 2015 中，我收到错误：

error C2752: 'Foo<FieldT,void>': more than one partial specialization matches the template argument list

我在这里缺少什么吗？

Answer 1

问题：应该使用哪个专业来调用foo<std::unique_ptr<int>>？

请注意，int不是类，因此值std::is_class<T>::value为 false，并且A版本不匹配。

如果您希望在第一个模板参数是std::unique_ptr时使用A版本，则可以将A版本编写为

template <typename T>
struct foo<std::unique_ptr<T>, 
typename std::enable_if<std::is_class<
std::unique_ptr<T>>::value>::type>
{ static int const value = 1; };

或者你可以这样写foo

template <typename T,
typename = typename std::enable_if<std::is_class<T>::value>::type> 
struct foo;
template <typename T>
struct foo<std::unique_ptr<T>>
{ static int const value = 1; };
template <typename T>
struct foo<T>
{ static int const value = 2; };

因此，A成为比B更专业的版本，您的代码可以编译。否则，您的A版本实际上是一个更专业的版本，B但编译器无法识别它。

观察

template <typename T>
struct foo<std::unique_ptr<T>, 
typename std::enable_if<std::is_class<
std::unique_ptr<T>>::value>::type>
{ static int const value = 1; };

代码编译和std::is_class<std::unique_prt<T>>::value永远是真的;但如果你写

template <typename T>
struct foo<std::unique_ptr<T>, 
typename std::enable_if<true>::type>
{ static int const value = 1; };

(事实上，这是等效的)代码无法编译

--编辑--

如果您希望foo<std::unique_ptr<int>匹配大小写B，您可以(通过示例)创建类型特征，如下所示

struct foo<T>
{ static int const value = 2; };
template <typename T>
struct proValue
: std::integral_constant<int, 2>
{ };
template <typename T>
struct proValue<std::unique_ptr<T>>
: std::integral_constant<int, std::is_class<T>::value ? 1 : 2>
{ };

并定义foo如下

template <typename T, int = proValue<T>::value>
struct foo;
template <typename T>
struct foo<std::unique_ptr<T>, 1>
{ static int const value = 1; };
template <typename T>
struct foo<T, 2>
{ static int const value = 2; };

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

#include <memory>
#include <vector>
#include <iostream>
#include <type_traits>
class Test
{ };
template <typename T,
typename = typename std::enable_if<std::is_class<T>::value>::type> 
struct foo;
template <typename T>
struct foo<std::unique_ptr<T>>
{ static int const value = 1; };
template <typename T>
struct foo<T>
{ static int const value = 2; };
template <typename T>
struct proValue
: std::integral_constant<int, 2>
{ };
template <typename T>
struct proValue<std::unique_ptr<T>>
: std::integral_constant<int, std::is_class<T>::value ? 1 : 2>
{ };
template <typename T, int = proValue<T>::value>
struct bar;
template <typename T>
struct bar<std::unique_ptr<T>, 1>
{ static int const value = 1; };
template <typename T>
struct bar<T, 2>
{ static int const value = 2; };
int main ()
{
std::cout << foo<std::vector<int>>::value << 'n';      // print 2
std::cout << foo<std::unique_ptr<int>>::value << 'n';  // print 1
std::cout << foo<std::unique_ptr<Test>>::value << 'n'; // print 1
std::cout << bar<std::vector<int>>::value << 'n';      // print 2
std::cout << bar<std::unique_ptr<int>>::value << 'n';  // print 2
std::cout << bar<std::unique_ptr<Test>>::value << 'n'; // print 1
}

Answer 2

我设置了一个小示例来更好地重现错误。

#include <iostream>
#include <memory>
#include <type_traits>
template < typename T, typename = void >
struct foo;
template < typename T >
struct foo < std::unique_ptr<T>,
typename std::enable_if<std::is_class<T>::value>::type >
{
static int const value = 1;
};
template < typename T >
struct foo < T,
typename std::enable_if<std::is_class<T>::value>::type >
{
static int const value = 2;
};
class Test;
int main()
{
std::cout << foo< std::unique_ptr<Test> >::value << 'n';
}

我认为Clang的错误非常明确

test.cpp:26:16: error: ambiguous partial specializations of
'foo<std::unique_ptr<Test, std::default_delete<Test> >, void>'
std::cout << foo< std::unique_ptr<Test> >::value << 'n';
^
test.cpp:9:8: note: partial specialization matches [with T = Test]
struct foo < std::unique_ptr<T>,
^
test.cpp:16:8: note: partial specialization matches [with T = std::unique_ptr<Test,
std::default_delete<Test> >]
struct foo < T,
^
1 error generated.

编译器应该如何知道您希望通过第一个专用化而不是T = std::unique_ptr<Test>来推断T = Test？ 此外，在这两种情况下，T都是一个使std::enable_if毫无意义的类。

Answer 3

除了亨利在他的回答中所说的之外，你可以(在有限的意义上)通过写一个近乎微不足道的is_unique_ptr特征来解决这个问题。

现场演示在这里。

我省略了代码，因为它从根本上存在缺陷。

---

你可以看到这已经失败了，对于一个非平凡的std::unique_ptr，但这可以通过扩展is_unique_ptr特征来解决。请注意，非常允许实现根据需要添加额外的(默认)模板参数，因此这永远不会是一个无懈可击的。

更合适的解决方案还包括修改foo模板专用化：

#include <iostream>
#include <memory>
#include <type_traits>
template<typename T>
struct is_unique_ptr : std::false_type {};
template<typename... UniquePtrArgs>
struct is_unique_ptr<std::unique_ptr<UniquePtrArgs...>> : std::true_type {};
template<typename T, typename = void>
struct foo;
template<typename... UniquePtrArgs>
struct foo<std::unique_ptr<UniquePtrArgs...>>
{
static int const value = 1;
};
template<typename T>
struct foo<T, typename std::enable_if<!is_unique_ptr<T>::value && std::is_class<T>::value>::type>
{
static int const value = 2;
};
class Test;
void f(Test*);
int main()
{
std::cout << foo<std::unique_ptr<Test>>::value << 'n';
std::cout << foo<Test>::value << 'n';
std::cout << foo<std::unique_ptr<Test, decltype(&f)>>::value << 'n';
}

现场演示在这里。

与其专注于std::unique_ptr，不如专注于具有特定属性的类型，即您在专用化中利用std::unique_ptr，这样您就不会绑定到特定类型，而是绑定到特定属性。