Using a Class Template's Internal Types from a Specialized Class

Question

EDIT: I didn't actually get a chance to test out any of the suggested solutions as I went on a vacation, and by the time I was back, the people responsible for the class template had made some changes that allowed me to get around the need to use types defined in the class template itself.

Thanks to everyone for their help though.

---

In a nutshell - and feel free to correct my wording, templates are still a bit of voodoo to me, - I need to know if I can use a (protected) struct or a #typedef defined inside a class template from my specialized class. For example:

This is the class template:

template<typename T>
class A : public C<T>
{
protected:
    struct a_struct { /* Class template implementation, doesn't depend on T */ };
    void foo( a_struct a );
};

Which I need to fully specialize for T = VAL:

template<>
class A< VAL > : public C< VAL >
{
    void foo( a_struct a )
    {
        // My implementation of foo, different from the class template's
    }
};

If I do something like this, however, the compiler complains that a_struct is undefined in my specialized class. I tried specializing and inheriting from the class template but that got... messy.

I saw some solutions, but all of them involved modifying the class template, which is something I am not able to easily do (different team).

Thoughts?

Answer 1

No, you can't use members of the primary template declaration in your specialization of the class template. That is because in essence a template class specialization declares a completely new class template that is applied when the template arguments match the specialization.

You have two options available though, if you want to do something like in your example:

• You can specialize the template class member function. This is useful if it is indeed only one member function that is special (or at least the number of member functions is limited).
• You can bring the declaration of the member (-type) in a common base class.

Since you indicated in an edit that you can't change the class template itself, specializing the member function seems the best option.

A simplified example of specializing a member function only

template< class T>
class Printer
{
public:
    struct Guard {};
    void DoPrint( const T& val)
    {
        Guard g;
        (void)g;
        std::cout << val << '\n';
    }
};

struct Duck {};

template<>
void Printer<Duck>::DoPrint( const Duck& val)
{
    Guard g;
    (void)g;
    std::cout << "Some duck\n";
}

The Guard here is only used to demonstrate that this type is available to both the primary and the specialized implementation of DoPrint().

Answer 2

It's not beautiful, but you can do it like this:

template<typename T>
class C
{

};

template<typename T>
class A : public C<T>
{
protected:
    friend A<int>;
  // ^^^^^^
    struct a_struct { /* Class template implementation, doesn't depend on T */ };
    void foo( a_struct a );
};

template<>
class A< int > : public C< int >
{
    using a_struct = typename A<void>::a_struct;
  // ^^^^^^
    void foo( a_struct a )
    {
        // My implementation of foo, different from the class template's
    }
};