Spécialisation partielle des modèles variadiques

Question

Considérons le modèle de classe "X" suivant et ses spécialisations partielles.

template <class ...Types>
struct X {};               // #1

template <class T1>
struct X<T1> {};           // #2

template <class T1, class ...Types>
struct X<T1, Types...> {}; // #3

X<int> x;                  // #2 or #3 ?

Je soupçonne que X<int> est ambiguë. Il l'est parce que :

Il est évident que les numéros 2 et 3 sont plus spécialisés que le numéro 1, les numéros 2 et 3 sont maintenant comparés. Selon 14.5.5.2, considérons lequel des #2' et #3' suivants est le plus spécialisé.

template <class T1>
void f(X<T1>);             // #2'

template <class T1, class ...Types>
void f(X<T1, Types...>);   // #3'

Selon 14.8.2.4, la première étape est la déduction du modèle d'argument en utilisant #2' comme modèle d'argument et #3' comme modèle de paramètre. Étant donné que le seul type d'argument est X<A1>, le T1 déduit est A1, et Types est vide.

A = X<A1>, P = X<T1, Types...>  =>  T1 = A1, Types = {}

La deuxième étape est effectuée en utilisant le modèle #3' comme modèle d'argument et le modèle #2' comme modèle de paramètre. Étant donné que le seul type d'argument est X<A1, Args...>, selon 14.8.2.5/9 (notez que ce paragraphe a été récemment révisé par N3281), Args est simplement ignoré, le T1 déduit est A1 et la déduction d'argument réussit.

A = X<A1, Args...>, P = X<T1>  =>  T1 = A1 (Args is ignored)

Enfin, les déductions d'arguments bidirectionnels ont réussi. Donc #2 est tout aussi spécialisé que #3. En conclusion, X<int> est ambiguë.

Ma question est la suivante : "Mon interprétation est-elle correcte ?"

Si cette interprétation est correcte, la définition de 'std::common_type' dans 20.9.7.6/3 est inappropriée.

template <class ...T>
struct common_type;            // #1

template <class T>
struct common_type<T>          // #2
{
    typedef T type;
};

template <class T, class U>
struct common_type<T, U>       // #3
{
    typedef
        decltype(true ? declval<T>() : declval<U>())
    type;
};

template <class T, class U, class ...V>
struct common_type<T, U, V...> // #4
{
    typedef typename
        common_type<typename common_type<T, U>::type, V...>::type
    type;
};

Lorsque common_type<A, B> est utilisé, les points 3 et 4 sont ambigus.

Note : sur le premier exemple, GCC 4.7.0 (snapshot) et Clang 3.0 sélectionnent #2. Cependant, ces compilateurs sont si peu fiables qu'ils ne suivent pas les autres changements de N3281.

Answer 1

14.8.2.4, section 11 (je me réfère au projet N3242).

Dans la plupart des cas, tous les paramètres du modèle doivent avoir des valeurs pour que la déduction soit réussie. pour que la déduction réussisse, mais à des fins d'ordonnancement partiel, un peut rester sans valeur, à condition qu'il ne soit pas utilisé dans l'élément types utilisés pour l'ordonnancement partiel. [Note : Un paramètre de modèle utilisé dans un contexte non instruit est considéré comme utilisé. -fin de la note] [ Exemple :

template <class T> T f(int); // #1
template <class T, class U> T f(U); // #2
void g() {
f<int>(1); // calls #1
}

Dans votre cas, c'est le n°3 qui sera utilisé.