Is it required to explicitly list default parameters when using template template parameter?

Question

I'd like to ask whether the following code sample should compile:

#include <iostream>
#include <vector>
#include <typeinfo>

using namespace std;

template <template <class...> class C>
struct convert_container
{
    using type = C<double>; 

    // Visual Studio requires this to be:
    // using type = C<double, std::allocator<doble>>
};

int main()
{
    std::cout << typeid(convert_container<std::vector>::type).name();
}

The code compiles fine with GCC 4.8.1 and Clang 3.4 but not with Visual Studio 2013. The error I get:

error C2976: 'std::vector' : too few template arguments
    c:\program files (x86)\microsoft visual studio 12.0\vc\include\vector(650) : see declaration of 'std::vector'
    c:\users\michał\documents\visual studio 2013\projects\transform\transform.cpp(14) : see reference to class template instantiation 'convert_container<std::vector>' being compiled

What does the standard say about this? Am I required to explicitly state all the parameters (including defaulted ones) when using the template template parameter C or is this just a bug in VC++?

Context: The issue araised from Constructor's answer to my previous question: https://stackoverflow.com/a/23874768/2617356

When searching the archives I've found this question: Default values in templates with template arguments ( C++ ) It's basically about the same problem, the question author states that default parameters for template template parameter "had to be" explicitly stated. However, the asker accepted solution that's not quite applicable in my case. The question was not about what is the standard-conforming behaviour, so I believe this is not a duplicate.

@dyp Yes, this answer seems to about my problem. The CWG issue #150 looks interesting. Great find, thank you! :) — Michał W. Urbańczyk, Jun 04 '14 at 14:17

score 3 · Accepted Answer · edited Jun 20 '20 at 09:12

Consider the similar

template <typename = void, int = 0> struct A { };
template <template <typename ...> class T> struct B : T<> { };
template class B<A>;

This is clearly covered by the standard (14.3.3p3 if you're interested, I won't quote it, as GCC and clang do both implement the rule already), where the use of A as a template argument for B is disallowed because of the non-type template parameter. That rule makes no sense if the instantiation of a template template parameter could make use of the template template argument's default template arguments, so the behaviour of MSVC and Intel is more consistent than that of GCC and clang.

Of course, the reasoning "if this were valid, the standard would have inconsistencies" doesn't actually mean it isn't valid, only that it shouldn't be valid. To actually check what the standard says:

14.1 Template parameters [temp.param]

10 The set of default template-arguments available for use with a template declaration or definition is obtained by merging the default arguments from the definition (if in scope) and all declarations in scope in the same way default function arguments are (8.3.6).

8.3.6 Default arguments [dcl.fct.default]

4 Declarations in different scopes have completely distinct sets of default arguments. That is, declarations in inner scopes do not acquire default arguments from declarations in outer scopes, and vice versa.

Although not specifically intended to address this use of default template arguments, I think it does manage to do so. Nikos Athanasiou has already included the part of the standard that says any default template arguments of C do get used:

14.1 Template parameters [temp.param]

14 A template-parameter of a template template-parameter is permitted to have a default template-argument. When such default arguments are specified, they apply to the template template-parameter in the scope of the template template-parameter.

Since C's default template arguments are used, std::vector's aren't, and MSVC and Intel seem to be correct here.

And to come up with an example that clearly shows that GCC and clang cannot be considered to conform here:

template <typename = char, typename = short>
struct A { };

template <template <typename = void, typename ...> class T>
struct B {
  using type = T<>;
};

Both GCC and clang treat B<A>::type as A<void, short>, taking one default template argument from T, and another from A, even though the standard disallows merging of default arguments (and hence default template arguments) in declarations in different scopes.

A workaround for you, to avoid the need to type out the allocator argument, could be to use a template alias:

template <template <class...> class C>
struct convert_container
{
  using type = C<double>; 
};

template <typename T>
using vector_default_alloc = std::vector<T>;

int main()
{
  std::cout << typeid(convert_container<vector_default_alloc>::type).name();
}

I cannot test on MSVC right now, but Intel accepts it, and I see no reason why this variant would be invalid.

Anyway, I would guess that it's not allowed *because of a mismatch*, i.e. deduction fails. That's different from what template arguments you later have to specify / whether the default template-parameters of the template argument can be implicitly used via the template template-parameter. — dyp, Jun 03 '14 at 22:58
@dyp Thanks, that was a typo, 14.3.3 was the one I meant. But no, deduction doesn't fail, see the example in 14.3.3p2, where `template — , Jun 03 '14 at 23:00
@dyp BTW, the example used to list these as ill-formed, the example got fixed to correct this (http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#744), so I'm fairly certain this is not a simple oversight in the example. — , Jun 03 '14 at 23:06

Nikos Athanasiou · Answer 2 · 2014-06-03T20:52:15.637

1

A (seemingly related) quote from the standard 14.1 Template parameters

14 . A template-parameter of a template template-parameter is permitted to have a default template-argument. When such default arguments are specified, they apply to the template template-parameter in the scope of the template template-parameter.

[ Example:

template <class T = float> struct B {};

template <template <class TT = float> class T> struct A {

inline void f();

inline void g();
};

template <template <class TT> class T> void A<T>::f() { // (*)
T<> t; // error - TT has no default template argument
}

template <template <class TT = char> class T> void A<T>::g() {
T<> t; // OK - T<char>
}

— end example ]

This is the only verse posing limitations to the use of default template parameters of template template parameters (verse 9,11,12 pose limitations on the definition/specification)

As stressed in the comments, OP's case does not involve a default parameter in convert_container (so the above does not apply explicitly). IMHO there are two ways of interpreting the situation :

using type = C<double> is a type alias for a class template; that class "loses" the right to use default template parameters, since it's passed as a template template parameter and all default arguments (of that TT parameter) lie outside the scope of the "typedefing". Then VS is correct.
By tracking the instantiation process : Say a correct compiler instantiates the struct as so ^{(it's just a type substitution - no actual representation of the actual instantiation process is implied)}
```
struct convert_container
{
    using type = vector<double>; 
};
```

then OP's case seems fairly legit (and gcc/clang are correct)

FWIW

This compiles in VS2013

template <template <class...> class C>
using tt = C<double>;

int main()
{
    std::cout << typeid(tt<std::vector>).name();
}

So the arguments of default template parameters being non legal to pass to template template parameters seems more and more shaky.

edited Jun 03 '14 at 20:52

answered Jun 03 '14 at 18:17

Nikos Athanasiou

29,616
15
87
153

Your answer states that `std::vector` is invalid outside of the body of `std::vector`, because the allocator is not specified. `std::vector` is widely known to be valid. Therefore, either the common knowledge is wrong, or your analysis is. What your analysis misses is that `std::vector`'s default template argument isn't a default template argument for a template parameter of a template template parameter, but your quote only applies to default template arguments for template parameters of template template parameters. – Jun 03 '14 at 19:42
Your quote says about default template arguments of template template parameters. Nothing about default template arguments of a class template which is passed as template template parameter. – Constructor Jun 03 '14 at 19:45
@hvd (`T`=template) Maybe my phrasing lost track there. What I get from the quote in this case, is that since `using type = C` is a type alias for a class `T`, that class "loses" the right to use default `T` parameters, since it's passed as a `TT` parameter and all default arguments (of that `TT` parameter) lie outside the scope of the "typedefing" – Nikos Athanasiou Jun 03 '14 at 20:11
1

But that isn't what the quote says. It *explicitly* states it applies to a default argument of a template parameter of a template template parameter. That's part of what you copied into your answer. There is no default argument of a template parameter of a template template parameter anywhere in the OP's code. – Jun 03 '14 at 20:14
@If that's not the case (and interpretation went too far into remixing), I can't find any other verse forbidding declarations such as the one OP attempted. So the verdic should be reversed. – Nikos Athanasiou Jun 03 '14 at 20:17
FWIW, I cannot find anything forbidding it either, but neither can I find anything that defines the behaviour. – Jun 03 '14 at 20:25
@hvd I'll be updating the answer to stress exactly that. – Nikos Athanasiou Jun 03 '14 at 20:27

Is it required to explicitly list default parameters when using template template parameter?

2 Answers2

FWIW

Linked

Related