Especialización de una función miembro de plantilla de una clase con plantilla sin especificar el parámetro de la plantilla de clase.
¿Cuál es la sintaxis correcta para especializar una función miembro con plantillas de una clase plantilla sin especificar el parámetro de plantilla de la clase?
Aquí está a lo que me refiero:
Ejemplo #1 (funciona):
“`c++
#include <iostream>
struct C1
{
template <class b="">
void f(void) const;
};
template <>
void C1::f<int>(void) const { std::cout<<777<<std::endl; }="" int="" main(void)="" {="" c1="" c1;=""></std::endl;><int>();
}
<pre><code><br />Ejemplo #2 (funciona):
“`c++
#include <iostream>
template <class a=””>
struct C2
{
template <class b=””>
void f(void) const;
};
template <>
template <>
void C2<int>::f<int>(void) const { std::cout<<888<<std::endl; }=”” int=”” main(void)=”” {=””></std::endl;><int> c2; c2.f<int>();
return 0;
}
Ejemplo #3 (no compila: “clases plantilla de encapsulación no están especializadas explícitamente”):
“`c++
#include <iostream>
template <class a="">
struct C3
{
template <class b="">
void f(void) const;
};
struct D { static int g(void){ return 999; } };
template <class a="">
template <>
void C3<a>::f<int>(void) const { std::cout<<><std::endl; }="" template=""></std::endl;><class a="">
template <>
void C3<a>::f<char>(void) const { std::cout<<><std::endl; }="" int="" main(void)="" {=""></std::endl;><d> c3a; c3a.f<int>(); // espero ver 1000
C3<d> c3b; c3b.f<char>(); // espero ver 1001
return 0;
}
“`
¿Cómo puedo hacer que el ejemplo #3 funcione?
davy.ai
Para que funcione el Ejemplo #3, necesitamos especializar explícitamente la plantilla de clase envolvente C3 para el parámetro de plantilla específico (en este caso, la clase D) antes de especializar su plantilla de función miembro. Esto se puede hacer de la siguiente manera:
“` c++
#include
template
struct C3
{
template
void f(void) const;
};
struct D { static int g(void){ return 999; } };
// especialización explícita de C3 para la clase D
template<>
struct C3
{
template
void f(void) const;
};
template(void) const { std::cout << A::g()+1 << std::endl; }
template<>
void C3::f
template<>::f(void) const { std::cout << D::g()+1 << std::endl; }
void C3
template(void) const { std::cout << A::g()+2 << std::endl; }
template<>
void C3::f
template<>::f(void) const { std::cout << D::g()+2 << std::endl; }
void C3
int main(void) c3a; c3a.f(); // esperamos ver 1000 c3b; c3b.f(); // esperamos ver 1001
{
C3
C3
return 0;
}
“`
En este código modificado, hemos especializado explícitamente la plantilla de clase C3 para la clase D antes de especializar sus funciones miembro, y las especializaciones de las plantillas de función miembro están correctamente vinculadas a la plantilla de clase especializada.