C++ от макросов до шаблонов

Question

Я пытаюсь изменить некоторые макросы (у нас есть их) для шаблонов функций. Много раз, у меня есть следующий сценарий:

#include <iostream> 

void function_A(void) 
{ 
    std::cout << "function A" << std::endl; 
} 

void function_B(void) 
{ 
    std::cout << "function B" << std::endl; 
} 

#define FOO(_bar) \ 
do { \ 
    /* ... do something */ \ 
    function_##_bar(); \ 
    /* ... do something */ \ 
} while(0) 

int main() 
{ 
    FOO(A); 
    FOO(B); 
} 

Как я могу выразить FOO как шаблон функции и достичь того же результата?

Я имею в виду что-то вроде:

template < ??? _bar > 
void foo() 
{ 
    // somehow link function_X and _bar 
} 

Performance является обязательным !!

Заранее спасибо.

Answer 1

Вы можете использовать случай заявление, как в ответ Zenith, но вы можете сделать это во время компиляции с помощью шаблонов, как это:

enum class FunctionOverload 
{ 
    A, B 
}; 

template <FunctionOverload T> 
void function(); 

template<> 
void function<FunctionOverload::A>() 
{ 
    std::cout << "function A" << std::endl; 
} 

template<> 
void function<FunctionOverload::B>() 
{ 
    std::cout << "function B" << std::endl; 
} 

template <FunctionOverload T> 
void foo() 
{ 
    //do stuff 
    function<T>(); 
    //do more stuff 
} 

int main() 
{ 
    foo<FunctionOverload::A>(); 
    foo<FunctionOverload::B>(); 
} 

Answer 2

Я не думаю, что для этого вам нужен шаблон функции. Вот одно решение:

enum foo { A, B }; 

void CallFunction(foo f) 
{ 
    switch(f) 
    { 
     case A: function_A(); break; 
     case B: function_B(); break; 
    } 
} 
... 
int main() 
{ 
    CallFunction(A); 
    CallFunction(B); 
} 

Answer 3

Вы на самом деле не можете сделать строку склеивание с помощью шаблонов. Может быть, лучший способ решить вашу реальную проблему, но самый простой способ решить ваш заявленный вопрос - передать адрес функции в шаблон (это имеет еще одно преимущество, что вы не ограничены функции, вы можете передавать все, что может быть вызвано без параметров):

template <typename Callable> 
void foo(Callable func) 
{ 
    // Stuff 
    func(); 
} 

int main() 
{ 
    foo(&function_a); 
    foo(&function_b); 
}