奇怪的类模板专门化

Question

我有一个类模板

template <class T>
class A
{
};

以及非常奇怪的专业化

template <>
class A<class T*> : private A<void *>
{
};

有人能解释这个结构的含义吗？

Answer 1

混淆声明了一个类T，并专门化了T*的模板

#include <iostream>

template <class T>
class A
{
    public:
    static void f() { std::cout << "Template" << '\n'; }
};

// Declare a class T and specialize the template for T*
template <>
class A<class T*> : private A<void *>
{
    public:
    static void f() { std::cout << "Specialization" << '\n'; }
};

class T {};

int main()
{
    // Template
    A<int*>::f();
    // Specialization
    A<T*>::f();
}

Answer 2

我认为预期的代码应该是：

template <class T>
class A<T *> : public A<void*>
{
};

这是一个部分专门化，将用于任何指针类型，而不是泛型类型。也就是说，任何时候使用指针类型实例化A时，它都将使用此解析，而不是泛型解析。

当然，你需要在这个声明之前实例化或者专门化A<void*>，，否则你将会有一个无限的递归：

template class A<void*>;

这是强制编译器重用代码的一种比较常见的习惯用法。也就是说，您知道A<T*>的每个实例基本上都是相同的，因为所有指针在幕后的行为都是相同的。因此，您提供了A<void*>的完整实例化，然后任何其他A<T*>都继承了它，在需要的地方进行内联强制转换。

因为A<T*>继承自A<void*>，所以它不需要在实例化中提供大量的类代码。更小的代码有望产生更好的性能。

前面是完整的示例，未经测试：

template <typename T>
class A
{
  public:
    A()
    :m_data(0)
    {}
    void set(T x)
    { m_data = x; }
    T get()
    { return m_data; }
    //here there will be more complex operations
  private:
    T m_data;
    //and a lot of data depending on T
};

template class A<void*>; //splicit instantiation

template <typename T>
class A<T*> : public A<void*>
{
  private:
    typedef A<void*> base_type;
  public:
    //only the public, and maybe protected, functions are needed
    //but the implementation is one-line each
    void set(T *x)
    { base_type::set(x); }
    T *get()
    { return static_cast<T*>(base_type::get()); }
};