Template specializations for inner class

Question

consider the following code :

struct X
{
    template <typename T>
    class Y
    {};
 };
template<>
class X::Y<double>{
};

here we are specializing the Y class for the type double and the code works fine. the problem is that if I change the code to this:

template<typename A>
struct X
{
    template <typename T>
    class Y
    {};
 };
template<typename A>
class X<A>::Y<double>{
};

the compiler will report an error:

'X::Y': explicit specialization is using partial specialization syntax, use template <> instead!

dose any one know how can I specialize class Y in this case?

Does doing what the error message says not help? Use `template<>` instead of `template` on the nested template specialization. — Mark B, Nov 15 '16 at 16:28
it dosen't work ! i tired this as well: template<> class X::Y{ }; — MEMS, Nov 15 '16 at 16:30

score 3 · Answer 1 · edited May 23 '17 at 12:09

3

You cannot specialize an inner template class without explicitly specializing the outer one as well. See this question for more details and a quote from the standard.

Workaround: create an outer class that takes both T and A in a detail namespace, and alias it inside X:

namespace impl
{
    template <typename A, typename T>
    struct Y { };
}

template<typename A>
struct X
{
    template <typename T>
    using Y = impl::Y<A, T>;
};

If you are fine with explicitly specializing both inner and outer class, you can use the following syntax:

template <>
template <>
class X<int>::Y<double>
{
    // ...
};

Example on wandbox

edited May 23 '17 at 12:09

Community

1
1

answered Nov 15 '16 at 16:30

Vittorio Romeo

90,666
33
258
416

what if I want to specialize it for specific X and Y like: template <> class X::Y{ }; in this case it also complains! it says: error C2992: 'X::Y': invalid or missing template parameter list – MEMS Nov 15 '16 at 16:34
@MEMS: you need double `template<>`. [Example on wandbox](http://melpon.org/wandbox/permlink/5QsXzayEWYB8Vz1E). – Vittorio Romeo Nov 15 '16 at 16:38
Updated my answer as well. – Vittorio Romeo Nov 15 '16 at 16:39

W.F. · Accepted Answer · 2016-11-15T17:07:38.580

2

The simple answer - you can't fully specialize templated inner class of templated outer class. But if you really want to achieve similar effect you could try partial specialization with dummy defaulted template parameter:

#include <iostream>

template<typename A>
struct X
{
    template <typename T, T* =nullptr>
    class Y{};
 };

template<typename A>
template<double *Ptr>
class X<A>::Y<double, Ptr> {
public:
    static constexpr int value = 1;
};

int main() {
    std::cout << X<int>::Y<double>::value << std::endl;
}

[live demo]

edited Nov 15 '16 at 17:07

answered Nov 15 '16 at 16:32

W.F.

13,888
2
34
81

1

the book :Advanced metaprogramming in classic c++, on page 33 says: Template specializations are valid only at the namespace level: struct X { template class Y {}; template <> // illegal, but usually tolerated by compilers class Y {}; }; template <> // legal class X::Y { }; so what you have done might work but not always ! – MEMS Nov 15 '16 at 16:38
@MEMS You're author might be right. After looking for standards examples I've realized I might been actually over-interpreting the `[temp.class.spec] /5`. Updating code – W.F. Nov 15 '16 at 17:09
1

@MEMS according to C++ Standard Core Language Active Issues `727. In-class explicit specializations` inline partial specialization of member class is well formed... so my previous code was indeed valid. Please find the [reference](http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#727) – W.F. Nov 17 '16 at 12:07

Template specializations for inner class

2 Answers2