C++ c++；从宏到模板

我正在尝试为函数模板更改一些宏（我们有很多宏）。很多时候，我有以下场景：

#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 );
}

表演是必须的

---

提前谢谢。

我认为您不需要函数模板。这里有一个解决方案：

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);
}

---

您可以使用Zenith答案中的case语句，但可以在编译时使用以下模板：

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>();
}

enum类函数重载
{
A、 B
};
模板
空函数（）；
模板
空函数（）
{
std：：cout你实际上不能用模板做那样的字符串粘贴。可能有更好的方法来解决你真正的问题，但我能想到的解决你所说问题的最直接的方法是将函数的地址传递给模板（这还有一个优点，即您不局限于函数，您可以传递任何可以无参数调用的内容）：

模板
void foo（可调用函数）
{
//东西
func（）；
}
int main（）
{
foo（和函数a）；
foo（和函数b）；
}
您能把原始代码的完整可编译示例放在下面吗？“很多时候，我有以下场景”-代码气味？你甚至不需要do/while：这只是为了确保原始宏不会改变周围代码的含义而耍的花招。谢谢@TartanLlama！！这就是我想要的！谢谢，很好的解决方案，但性能是必须的。我们负担不起这些分支。在我看来，这也是最简单的解决方案。Es特别是因为您还可以传递其他可调用项（函数对象、lambda、functor）……这对我来说没有什么意义。如果您必须在main（）中编写“function\u a”，为什么不直接调用它呢？FOO宏的目的是避免键入“function\u”。
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>();
}

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

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