模板 class 中的部分特化模板 static constexpr

Question

(A toy, minimal not-working example)

The next code won't compile with cpp20/17:

template<typename TSomeTemplate>
struct A
{
    static constexpr size_t B = 1;

    template<typename T, typename... Ts>
    static constexpr size_t C = 4;

    template<typename T>
    static constexpr size_t C<T> = B;
};

int main()
{
    A<int>::C<int>;

    return 0;
}

With the error of "Expression did not evaluate to constant" regarding the last line in the struct. However, it does compile with full specialization, or without referencing B:

template<typename TSomeTemplate>
struct Works
{
    static constexpr size_t B = 1;

    template<typename T, typename... Ts>
    static constexpr size_t C = 4;

    template<>
    static constexpr size_t C<int> = B;
};

template<typename TSomeTemplate>
struct AlsoWorks
{
    static constexpr size_t B = 1;

    template<typename T, typename... Ts>
    static constexpr size_t C = 4;

    template<typename T>
    static constexpr size_t C<T> = 2;
};

Why is it so? How can I make the first struct work?

Answer 1

you cant specialize this way, you could use SFINAE or you may try something like:

template<typename TSomeTemplate>
struct A
{
    static constexpr size_t B = 1;

    template<typename T, typename... Ts>
    static constexpr size_t C = sizeof...(Ts) == 0 ? B : 4;
};

Answer 2

I was able to compile your code by adding template keyword.

template<typename TSomeTemplate>
struct A
{
    static constexpr size_t B = 1;

    template<typename T, typename... Ts>
    static constexpr size_t C = 4;

    template<typename T>
    static constexpr size_t C<T> = B;
};

int main()
{
    A<int>::template C<int>;

    return 0;
}

As cited here .

Similarly, in a template definition, a dependent name that is not a member of the current instantiation is not considered to be a template name unless the disambiguation keyword template is used or unless it was already established as a template name:

Answer 3

I don't see anything wrong with the code.

template<typename T>
static constexpr size_t C<T> = B;

This is a partial specialization of the C variable template, which is allowed, also inside the class scope. It is also more specialized than the primary template.

B is clearly a constant expression since it has been defined before as constexpr variable. Even if it was declared only as const instead it would still be usable in a constant expression (because it is of integral type). The compiler is wrong to reject it as not a constant expression.

It seems there are simply a few compiler bugs at play here (GCC seems to not like the variable template partial specialization inside the class scope and MSVC seems to have an issue with the constness of B . Clang does not complain.)

Answer 4

GCC and MSVC are wrong in rejecting the code as the program is well-formed.

B is a constant expression and can be used as an initializer when initializing C during its partial specialization. This is a msvc bug reported here as:

MSVC rejects valid code when using constexpr static data member as initializer .

---

Moreover, we are allowed to provide a partial specialization for C (as you did). This is a gcc bug reported as:

GCC rejects valid code involving partial specialization of variable template .