Mientras lee this, estoy confundido por los siguientes ejemplos:función de plantilla especialización
// Example 2: Explicit specialization
//
template<class T> // (a) a base template
void f(T);
template<class T> // (b) a second base template, overloads (a)
void f(T*); // (function templates can't be partially
// specialized; they overload instead)
template<> // (c) explicit specialization of (b)
void f<>(int*);
// ...
int *p;
f(p); // calls (c)
Aquí, (c)
es una especialización explícita de (b)
.
// Example 3: The Dimov/Abrahams Example
//
template<class T> // (a) same old base template as before
void f(T);
template<> // (c) explicit specialization, this time of (a)
void f<>(int*);
template<class T> // (b) a second base template, overloads (a)
void f(T*);
// ...
int *p;
f(p); // calls (b)! overload resolution ignores
// specializations and operates on the base
// function templates only
Aquí (c)
es una especialización explícita de (a)
. ¿Porqué es eso? ¿Esto es por el orden de la declaración?
Offhand Solo diría "sí", y suponiendo que el código sea válido, esa es la única respuesta posible. Pero la pregunta es si el segundo código es válido. Creo que es válido, pero encontrar esto en el estándar podría ser mucho trabajo ... –
@Alf P. Steinbach: ¿por qué el segundo código no podría ser válido? – Donotalo
@Donato: sin tener en cuenta los autores (que Really (TM) conocen sus cosas en lo que respecta a las plantillas), solo desconfío del código que tiene un efecto dependiente del orden u otro efecto más "arbitrario". El estándar está diseñado para proteger contra tales cosas, por ejemplo, la compilación en dos fases de las plantillas protege contra ese tipo de cosas. Entonces solo tengo un <0.5% siente que puede haber alguna regla al respecto, y posiblemente una que no requiera ningún diagnóstico. –