Ordenación parcial de plantillas de función-llamada ambigua

Estoy publicando los detalles de mi comprensión actual del problema como una respuesta. No estoy seguro de que sea la última palabra sobre esto, pero podría servir como base para una mayor discusión si es necesario. Los comentarios de dyp, hvd y Columbo han sido esenciales para encontrar los diversos bits de información a los que se hace referencia a continuación.

Como sospechaba, el problema es con las reglas para ordenar parcialmente las plantillas de funciones. Sección [14.8.2.4] (Deducir argumentos de plantilla durante parcial ordering) dice que, después de las transformaciones preliminares que eliminan referencias y calificadores cv, la deducción de tipos se realiza como se describe en [14.8.2.5] (Deducir argumentos de plantilla de un tipo ). Esa sección es diferente de la que se refiere a las llamadas a funciones-que sería [14.8.2.1] (Deducir argumentos de plantilla de una llamada a función ).

Cuando los parámetros de plantilla se deducen de los tipos de argumentos de función, hay algunos casos especiales que se permiten; para ejemplo, un parámetro de plantilla T utilizado en un parámetro de función de tipo T* se puede deducir cuando el argumento de la función es T[i], porque la conversión de matriz a puntero está permitida en este caso. Sin embargo, este no es el proceso de deducción que se utiliza durante el ordenamiento parcial, a pesar de que todavía estamos hablando de funciones.

Supongo que la forma fácil de pensar en las reglas para la deducción de argumentos de plantilla durante el pedido parcial es decir que son las mismas reglas que para deducir argumentos de plantilla al hacer coincidir especializaciones de class template.

Claro como el barro? Tal vez un par de ejemplos ayuden.

Esto funciona, porque utiliza las reglas para deducir argumentos de plantilla de una llamada a función :

#include <iostream>
#include <type_traits>

template<typename T> void f(T*)
{
    std::cout << std::is_same<T, int>::value << '\n';
}

int main()
{
    int a[3];
    f(a);
}

E imprime 1.

Esto no lo hace, porque usa las reglas para deducir argumentos de plantilla de un tipo :

#include <iostream>

template<typename T> struct A;

template<typename T> struct A<T*>
{
    static void f() { std::cout << "specialization\n"; }
};

int main()
{
    A<int[3]>::f();
}

Y el error de Clang es

error: implicit instantiation of undefined template 'A<int [3]>'

El la especialización no se puede usar, porque T* y int[3] no coinciden en este caso, por lo que el compilador intenta crear una instancia de la plantilla primaria.

Es este segundo tipo de deducción que se utiliza durante el pedido parcial.

Volvamos a nuestras declaraciones de plantillas de función:

template<typename T> void f(T, const char*); //#1
template<std::size_t N> void f(int, const char(&)[N]); //#2

Mi descripción del proceso de pedido parcial se convierte en:

• Deducción de argumento de plantilla con #1 como parámetro y #2 as argumento: inventamos un valor de M para sustituir N, T se deduce como int, pero un parámetro de tipo const char* no coincide con un argumento de tipo char[M], por lo que #2 es no al menos especializados, como #1 para el segundo par de tipos.
• Deducción de argumento de plantilla con #2 como parámetro y #1 como argumento: inventamos un tipo U para sustituir T, int and U do not match (different types), a el parámetro de tipo char[N] no coincide con un argumento de tipo const char*, y el valor del parámetro de plantilla que no es de tipo N no se puede deducir de los argumentos, por lo que #1 es no al menos tan especializado como #2 para cualquier par de tipos.

Dado que, para ser elegido, una plantilla debe ser al menos tan especializada como la otra para todos los tipos, se deduce que ninguna plantilla es más especializada que la otra y la llamada es ambiguo.

La explicación anterior va en contra de la descripción de un problema similar en Core Language Active Issue 1610 (enlace proporcionado por hvd).

El ejemplo es:

template<class C> void foo(const C* val) {}
template<int N> void foo(const char (&t)[N]) {}

El autor argumenta que, intuitivamente, la segunda plantilla debe elegirse como más especializada, y que esto no sucede actualmente (ninguna plantilla es más especializada que la otra).

Luego explica que la razón es la eliminación de el calificador const de const char[N], rindiendo char[N], que hace que la deducción falle con const C* como parámetro.

Sin embargo, basado en mi entendimiento actual, la deducción fallaría en este caso, const o no const. Esto es confirmado por las implementaciones actuales en Clang y GCC: si eliminamos el calificador const de los parámetros de ambas plantillas de función y llamamos a foo() con un argumento char[3], la llamada sigue siendo ambigua. Arrays y punteros simplemente no coinciden de acuerdo con el reglas actuales durante el pedido parcial.

Dicho esto, no soy miembro del comité, por lo que puede haber más de lo que actualmente entiendo.

Actualización: Recientemente me he topado con otro problema activo que se remonta a 2003: problema 402.

El ejemplo de allí es equivalente al de 1610. Los comentarios sobre el problema dejan claro que las dos sobrecargas no están ordenadas de acuerdo con el algoritmo de ordenación parcial tal como está, precisamente debido a la falta de reglas de decaimiento de matriz a puntero durante el ordenamiento parcial.

El último comentario es:

Hubo cierto sentimiento de que sería deseable tener este caso ordenado, pero no creemos que valga la pena gastar el tiempo para trabajar en él ahora. Si nos fijamos en algunos cambios de orden parcial más grandes en algún momento, vamos a considerar esto de nuevo.

Por lo tanto, estoy bastante seguro de que la interpretación que di arriba es correcto.