奇怪的类模板专业化

Question

I have a class template

template <class T>
class A
{
};

and very strange specialization

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

Can anybody explain the meaning of this construction ?

Answer 1

The obfuscation declares a class T and specialize the template for 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

I think that the intended code would be:

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

That is a partial specialization that will be used for any pointer type, instead of the generic one. That is, any time A is instantiated using a pointer type, it will use this declearation instead of the generic one.

Naturally you need to instantiate, or otherwise spezialize the A<void*> , before this declaration, or else you will have an infinite recursion:

template class A<void*>;

This is a somewhat common idiom to force the compiler to reuse code. That is, you know that every instance of A<T*> is basically the same, as all pointers will behave identically under the hood. So you provide the full instantiation of A<void*> and then any other A<T*> inherits from it, doing the casts inline where needed.

Since A<T*> inherits from A<void*> it does not need to provide the bulk of the class code in its instantiation. Smaller code will hopefully will yield better performance.

Full example ahead, untested:

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()); }
};