Matching between class template with default template argument and template parameter

First, explain this strange looking title .

“ Class template with default template parameters ” Refer to Class template with default template-parameter, That is, some or all template parameters of a class template have default values , such as ：

template<typename T1, typename T2 = int>
struct Foo {
     };

A typical example is std::vector, It actually has two template parameters ：

template<class T, class Allocator = std::allocator<T>>
class vector;

But in most cases , We don't need to specify the second template parameter , It feels like it has only one template parameter , such as ：std::vector<int> vec;.

“ Template parameters ” namely Template template parameter, That is, template parameters with templates , such as ：

template <template <typename> class C, typename T>
void bar(const C<T>& c) {
     }

Inside C Is a template parameter .

Now? , The problem is coming. , In the existing class Foo And the function bar() As defined , Can the following code be compiled ？

bar(Foo<int>{
    });

This question is actually asking ,template<typename T1, typename T2 = int> Can you talk to template <typename> class C Match .

One side ,C This class template can only have one template parameter , and Foo There are two template parameters , So it seems that the two should not match . But on the other hand ,Foo The second template parameter has a default value , In practical use, it can be regarded as having only one template parameter , So it seems to match C.

The answer to this question is ： Depends on the compiler ！

See cppreference,C++17 A new feature has been introduced Matching template template parameters to compatible arguments ( Template parameters match compatible arguments , There seems to be no simpler name , Call it MTTP2CA Well ) To solve CWG 150 problem , Enables the following code to compile ：

template<class T> class A {
     /* ... */ };
template<class T, class U = T> class B {
     /* ... */ };
template <class ...Types> class C {
     /* ... */ };
 
template<template<class> class P> class X {
     /* ... */ };
X<A> xa; // OK
X<B> xb; // OK in C++17 after CWG 150
         // Error earlier: not an exact match
X<C> xc; // OK in C++17 after CWG 150
         // Error earlier: not an exact match

therefore , I won't support it C++17 Your compiler cannot compile bar(Foo<int>{}); Of . But the problem is not limited to this , Even the latest Clang 12 and MSVC v19, Not even , Only GCC Be able to compile such code , Why is that ？

as a result of MTTP2CA The feature actually has a flaw , Suppose that bar() Function adds a new definition ：

template <template <typename, typename> class C, typename T1, typename T2>
void bar(const C<T1, T2>& c) {
     }

here bar(Foo<int>{}); The match is void bar(const C<T>& c); still void bar(const C<T1, T2>& c); Well ？

Allied , If you add a new class template ：

template <class>
struct Bar;

template <template <class> class X, class T>
struct Bar<X<T>> {
     };

template <template <class, class> class X, class T, class U>
struct Bar<X<T, U>> {
     
};

that Bar<Foo<int>> a; The match is Bar<X<T>> still Bar<X<T, U>> Well ？

In fact, these two situations are MTTP2CA There is no definition in , in other words C++ The standard does not specify that the former should be matched at this time （ A template parameter ） Or the latter （ Two template parameters ）. My test results are GCC Will choose to match the latter .

Because this undefined situation ,Clang and MSVC This feature is hidden by default .Clang Can pass -frelaxed-template-template-args Compile options to turn on the feature ,MSVC I haven't found a way to open it yet .

GCC and Clang The inconsistency on this issue also brings a more magical phenomenon ： If you IDE It's using QtCreator, And turned on ClangCodeModel plug-in unit （ Automatically analyze code problems , Higher version QtCreator Default on ）, So when compiling the previously mentioned code ,QtCreator Will report a mistake （ClangCodeModel be based on Clang Analyze the code ）, But at the same time, it can compile successfully （Linux Upper QtCreator By default GCC As a compiler ）.