c++ - microsoft - visual studio installer

Puntero de función única C++ para todas las instancias de plantilla

Question

¿Hay una forma concisa para apuntar a todas las instancias de una función de plantilla sin usar macros?

Tengo varias funciones de plantilla que quiero probar en una variedad de tipos:

template<typename T>
void function1() {
return;
}
template<typename T>
void function2() {
return;
}
template<typename T>
void function3() {
return;
}

Puedo hacer esto con una macro:

#define TEST_ACROSS_TYPES(fn) /
fn<int>(); /
fn<bool>(); /
fn<char>(); /
fn<double>(); /
TEST_ACROSS_TYPES(function1);
TEST_ACROSS_TYPES(function2);

Pero, (1) las macros son feas y difíciles de seguir para otros, y (2) estoy usando CATCH , que no funciona bien cuando se usan macros para configurar casos de prueba.

¿Hay alguna manera de hacer algo como esto?

void testAcrossTypes(SomeType f) {
f<int> ();
f<bool> ();
f<char> ();
f<double> ();
}

que parece mucho más limpio, excepto por el problema de definir SomeType . Esta pregunta ( Cómo definir el tipo de deflector de función que tiene argumentos de plantilla ) explica cómo definir un puntero a una función de plantilla; pero requiere que se especifiquen los argumentos de la plantilla.

Para aclarar: Imagine function1 , function2 y function3 cada prueba una función diferente de plantilla. Cada función necesita ser probada para int , byte , char , double , etc. Quiero evitar tener que configurar explícitamente muchas (es decir, num_functions * num_types) pruebas para cada función. En cambio, quiero tener un único método que apunte a la función de prueba ( function1 , function2 , etc.) y la ejecute para cada tipo de plantilla, consolidando así

function1<int>();
function1<byte>();
function1<char>();
function1<double();
...
function2<int>();
function2<byte>();
function2<char>();
function2<double();
...
function3<int>();
function3<byte>();
function3<char>();
function3<double();
...

en una sola llamada por función de prueba

testAcrossTypes(function1);
testAcrossTypes(function2);
testAcrossTypes(function3);

Answer 1

Lo que estás tratando de lograr con

void testAcrossTypes(SomeType f) {
f<int> ();
f<bool> ();
f<char> ();
f<double> ();
}

sería posible si SomeType pudiera ser un argumento de plantilla de plantilla. Sin embargo, el estándar no permite plantillas de funciones como argumento de plantilla de plantilla.

Del estándar C ++ 11:

14.3.3 Argumentos de plantilla de plantilla

1 Una plantilla-argumento para una plantilla plantilla-parámetro será el nombre de una plantilla de clase o una plantilla de alias, expresada como expresión-id.

Su mejor opción es usar funtores en lugar de funciones. Ejemplo:

template<typename T>
struct function1
{
void operator()() {
return;
}
};
template<typename T>
struct function2
{
void operator()() {
return;
}
};
template < template <typename> class F>
void testAcrossTypes() {
F<int>()();
F<bool>()();
F<char>()();
F<double>()();
}
int main()
{
testAcrossTypes<function1>();
testAcrossTypes<function2>();
}

Answer 2

Puedes lograrlo por medio de un functor borrado, como el del siguiente ejemplo:

#include<vector>
template<typename T>
void function1() { }
template<typename T>
void function2() { }
template<typename T>
void function3() { }
struct Test {
template<typename T>
static void proto() {
function1<T>();
function2<T>();
function3<T>();
}
void operator()() {
for(auto &f: vec) f();
}
template<typename... T>
static Test create() {
Test test;
int arr[] = { (test.vec.emplace_back(&proto<T>), 0)... };
(void)arr;
return test;
}
using func = void(*)(void);
std::vector<func> vec;
};
void testAcrossTypes(Test test) {
test();
}
int main() {
testAcrossTypes(Test::create<int, bool, char, double>());
}

Es fácil de modificar en ambos casos:

• Se deben agregar nuevas funciones al método de miembro proto estático y eso es todo

• Agregar un nuevo tipo es una cuestión de usarlo cuando se create llamada, como se muestra en el ejemplo anterior

El funtor se encargará de crear las llamadas N * M para ser ejecutadas.
Además, no necesita mover sus funciones en un conjunto de estructuras para poder usarlas.