C++ 混淆部分模板专门化

我看到了这段代码，它让我很困惑：

#include <boost/static_assert.hpp>
#include <boost/type_traits.hpp>
#include <boost/utility/enable_if.hpp>

template<class TT, typename Enable = void> struct UU { BOOST_STATIC_ASSERT_MSG(sizeof(TT) == 0, "undefined UU"); };

template<class TT>
struct UU<
        TT,
        typename boost::enable_if_c<
                !boost::is_same<
                        TT,
                        typename boost::remove_cv<
                                typename boost::decay<TT>::type
                            >::type
                    >::value
                || boost::is_pointer<TT>::value
            >::type
    >
    : UU<
            typename boost::remove_cv<
                typename boost::decay<
                    typename boost::remove_pointer<TT>::type
                >::type
            >::type
        >
{};

#包括
#包括
#包括
模板结构UU{BOOST_STATIC_ASSERT_MSG（sizeof（TT）==0，“未定义的UU”）；}；
模板
结构UU<
TT，
typename boost：：启用\u if\u c<
!boost：：是一样的吗<
TT，
typename boost：：删除<
typename boost:：decay:：type
>：：类型
>：：价值
||boost:：is_指针：：值
>：：类型
>
：UU<
typename boost：：删除<
类型名boost:：decay<
typename boost:：删除\指针：：类型
>：：类型
>：：类型
>
{};

我知道我只能问一个问题，但我不知道如何用一个问题来表达我的困惑，所以我提前道歉

我已经读过了，但是enable_if_c的模板参数令人困惑。这是否意味着如果TT与衰减的TT不同，或者如果TT是指针，则存在部分模板专门化

其次，结构从自身继承意味着什么？在这种情况下，UU是从UU（自身）继承的吗？这是某种递归模板吗

---

（代码编译时没有错误。）

它继承自UU，但实例化不同（例如，如果传递的类型是int*const*，即使删除了第一级指针和cv，它仍然是指针）。但是，它确实确保没有传递void**（因为void参数最终会触发带有静态断言的主窗体）。

它继承自UU，但实例化是不同的（例如，如果传递的类型是int*const*，即使移除了第一级指针和cv，它仍然是指针）. 但是，它确实确保void**未被传递（因为void参数最终将触发带有静态断言的主窗体）

这是否意味着如果TT与衰减的TT不同，或者如果TT是指针，则存在部分模板专门化

没错。否则将出现替换失败，主模板将用于传入的类型参数

TT

其次，结构从自身继承意味着什么？在这种情况下，UU是从UU（自身）继承的吗？这是某种递归模板吗

它不是从自身继承，而是从类模板的另一个实例化继承。它不是真正的递归，因为其他实例化是通过向其中传递另一个修改过的类型创建的。尽管如果将模板看作是在类型上操作的元函数，那么这确实是递归调用。与函数式编程非常相似

其思想是将复合类型简化为由其组成的类型。因此，引用类型的引用、数组元素类型的数组和指针对象类型的指针。继承允许该过程继续，直到我们手中没有复合类型为止

最终，主模板检查简化类型的正确性（在本例中，大小为非零）

这是否意味着如果TT与衰减的TT不同，或者如果TT是指针，则存在部分模板专门化

没错。否则将出现替换失败，主模板将用于传入的类型参数

TT

其次，结构从自身继承意味着什么？在这种情况下，UU是从UU（自身）继承的吗？这是某种递归模板吗

它不是从自身继承，而是从类模板的另一个实例化继承。它不是真正的递归，因为其他实例化是通过向其中传递另一个修改过的类型创建的。尽管如果将模板看作是在类型上操作的元函数，那么这确实是递归调用。与函数式编程非常相似

其思想是将复合类型简化为由其组成的类型。因此，引用类型的引用、数组元素类型的数组和指针对象类型的指针。继承允许该过程继续，直到我们手中没有复合类型为止

---

最终，主模板检查简化类型的正确性（在本例中，大小为非零）。

我想我现在明白了。下面是一个模拟示例：

#include <boost/static_assert.hpp>
#include <boost/type_traits.hpp>
#include <boost/utility/enable_if.hpp>
#include <typeinfo>
#include <iostream>

template<class TT, typename Enable = void> struct UU { BOOST_STATIC_ASSERT_MSG(sizeof(TT) == 0, "undefined UU"); };

template<class TT>
struct UU<
        TT,
        typename boost::enable_if_c<
                !boost::is_same<
                        TT,
                        typename boost::remove_cv<
                                typename boost::decay<TT>::type
                            >::type
                    >::value
                || boost::is_pointer<TT>::value
            >::type
    >
    : UU<
            typename boost::remove_cv<
                typename boost::decay<
                    typename boost::remove_pointer<TT>::type
                >::type
            >::type
        >
{
    UU()
    {
        std::cout << __PRETTY_FUNCTION__ << std::endl;
    }
};

struct dummy
{
    dummy()
    {
        std::cout << __PRETTY_FUNCTION__ << std::endl; 
    }
};

template<>
struct UU<dummy>
{
    UU()
    {
        std::cout << __PRETTY_FUNCTION__ << std::endl;
    }
};

int main()
{
    typedef dummy**& mytype;
    std::cout << typeid(typename boost::remove_cv<typename boost::decay<mytype>::type>::type).name() << std::endl;
    std::cout << boost::is_pointer<mytype>::value << std::endl;
    std::cout << boost::is_same<mytype, typename boost::remove_cv<typename boost::decay<mytype>::type>::type>::value << std::endl;

    UU<mytype> uu;
    return 0;
}

#包括
#包括
#包括
#包括
#包括
模板结构UU{BOOST_STATIC_ASSERT_MSG（sizeof（TT）==0，“未定义的UU”）；}；
模板
结构UU<
TT，
typename boost：：启用\u if\u c<
!boost：：是一样的吗<
TT，
typename boost：：删除<
typename boost:：decay:：type
>：：类型
>：：价值
||boost:：is_指针：：值
>：：类型
>
：UU<
typename boost：：删除<
类型名boost:：decay<
typename boost:：删除\指针：：类型
>：：类型
>：：类型
>
{
UU（）
{
我想我现在明白了。这是一个模拟示例：

#include <boost/static_assert.hpp>
#include <boost/type_traits.hpp>
#include <boost/utility/enable_if.hpp>
#include <typeinfo>
#include <iostream>

template<class TT, typename Enable = void> struct UU { BOOST_STATIC_ASSERT_MSG(sizeof(TT) == 0, "undefined UU"); };

template<class TT>
struct UU<
        TT,
        typename boost::enable_if_c<
                !boost::is_same<
                        TT,
                        typename boost::remove_cv<
                                typename boost::decay<TT>::type
                            >::type
                    >::value
                || boost::is_pointer<TT>::value
            >::type
    >
    : UU<
            typename boost::remove_cv<
                typename boost::decay<
                    typename boost::remove_pointer<TT>::type
                >::type
            >::type
        >
{
    UU()
    {
        std::cout << __PRETTY_FUNCTION__ << std::endl;
    }
};

struct dummy
{
    dummy()
    {
        std::cout << __PRETTY_FUNCTION__ << std::endl; 
    }
};

template<>
struct UU<dummy>
{
    UU()
    {
        std::cout << __PRETTY_FUNCTION__ << std::endl;
    }
};

int main()
{
    typedef dummy**& mytype;
    std::cout << typeid(typename boost::remove_cv<typename boost::decay<mytype>::type>::type).name() << std::endl;
    std::cout << boost::is_pointer<mytype>::value << std::endl;
    std::cout << boost::is_same<mytype, typename boost::remove_cv<typename boost::decay<mytype>::type>::type>::value << std::endl;

    UU<mytype> uu;
    return 0;
}

#包括
#包括
#包括
#包括
#包括
模板结构UU{BOOST_STATIC_ASSERT_MSG（sizeof（TT）==0，“未定义的UU”）；}；
模板
结构UU<
TT，
typename boost：：启用\u if\u c<
！boost：：是吗<
TT，
typename boost：：删除<
typename boost:：decay:：type
>：：类型
>：：价值
||boost:：is_指针：：值
>：：类型
>
：UU<
typename boost：：删除<
me@ub16:~/tmp/traits$ g++ -I~/me/bin/boost_1_60_0 c.cpp && ./a.out
In file included from c.cpp:1:0:
c.cpp: In instantiation of ‘struct UU<dummy, void>’:
c.cpp:10:8:   recursively required from ‘struct UU<dummy**, void>’
c.cpp:10:8:   required from ‘struct UU<dummy**&>’
c.cpp:62:13:   required from here
c.cpp:7:56: error: invalid application of ‘sizeof’ to incomplete type ‘boost::STATIC_ASSERTION_FAILURE<false>’
 template<class TT, typename Enable = void> struct UU { BOOST_STATIC_ASSERT_MSG(sizeof(TT) == 0, "undefined UU"); };