本文代码需要c++17支持(可自行修改以兼容c++11)
概述
有时候我们会对相同的数据做不同的操作，例如：

int add(int a, int b) { return a + b; }
int mul(int a, int b) { return a * b; }
int do_sth(int a, int b, const std::string& function_name) {
        if (function_name == "add") return add(a, b);
        if (function_name == "mul") return mul(a, b);
}
这种做法是可行的，但是当我们还需要添加sub(a, b)，div(a, b)等等的多个函数时，每添加一个函数，我们都要在do_sth中添加一个if，很容易出错，也不符合开闭原则。

另一种实现方法是将每个操作单独封装成一个类，然后使用工厂模式创建。这种做法是符合开闭原则的，但是每添加一个函数就要添加一个类未免也太繁琐了。

理想情况下，倘若有一门语言同时结合了c++, Java,Python，应该这样添加函数：

// 函数管理类FunctionManager
//     @Register()：将函数注册到这个类中
//     getFunction(): 将已注册的函数返回
class FunctionManager;

@Register("add") // 将函数add注册到FunctionManager，通过字符串"add"能够找到这个函数
int add(int a, int b) { return a + b; }
@Register("mul") // 将函数mul注册到FunctionManager，通过字符串"mul"能够找到这个函数
int mul(int a, int b) { return a * b; }
int do_sth(int a, int b, const std::string& function_name) {
        // 函数管理类根据function_name返回一个std::function
        std::function<int(int, int)> Function = FunctionManager.getFunction(function_name);
        return Function(a, b);
}
FunctionManager: 管理函数的类
@Register("Add"): 将函数指针和函数签名(能够唯一标识该函数的字符串)添加到FunctionManager中
FunctionManager.getFunction(): 根据函数签名返回函数指针
很明显，当前的c++不支持@Register，退而求其次我们使用宏进行注册，最终本文实现的效果是(在最后提供了可运行的完整程序)：

// xxx.h
int add(int a, int b);
// xxx.cpp
// 注册函数，参数为：变量名(ADD)，函数签名("ADD")，函数指针(add)
_REGISTER_FUNCTION(ADD, "ADD", add);
int add(int a, int b) { return a + b; }
// main.cpp
int do_sth(int a, int b, const std::string& func_sig) {
        // FunctionManager是一个单例
        auto p_function_manager = FunctionManager<decltype(add)>::getInstance();
        // 此处返回已注册的函数
        auto func = p_function_manager->getFunction(func_sig);
        return
}
实现
我们将管理函数的类命名为FunctionManager。仔细分析我们的需求，不难发现实际上我们需要根据字符串查找已注册的函数对象。

查找的实现
STL中已经有了能够满足我们需求的std::map<std::string, FunctionType>容器，因此查找功能已经实现了。需要注意的有：

FunctionType需要外部提供，而函数的返回值、参数都会改变都会影响FunctionType，我们不可能把FunctionType硬编码到程序中，这时候就需要模板。
由于函数指针不能够作为函数的返回值，获取函数的接口只能返回std::function，因此map中存储的也应当是std::function。
考虑到程序中仅有一个FunctionManager，将FunctionManager设置为单例更方便(同时也能满足注册函数的需求)。
template <typename FunctionType>
class FunctionManager {
        // 没有delete这个指针，考虑到这是demo，忽略这个问题
        inline static FunctionManager<FunctionType>* p_function_manager = nullptr;

        std::map<std::string, FunctionType> m_sig_func_map;

public:
        static FunctionManager<FunctionType>* get_instance() {
                if (!p_function_manager) p_function_manager = new FunctionManager<FunctionType>;
                return p_function_manager;
        }
       
        // 实际上不能使用运算符[]，因为当map中sig不存在时会自动创建一个<sig, empty>对象，demo中忽略这个问题
        FunctionType get_function(const std::string& sig) { return m_sig_func_map[sig]; }
};
注册的实现
注册实际上就是将函数签名(字符串)和函数(std::function对象)添加到FunctionManager::m_sig_func_map中,只需要添加一个接口：

        // 也可以使用insert，二者间存在一点区别
        void register_function(const std::string& sig, FunctionType function) { m_sig_func_map[sig] = function; }
尝试使用
到这里我们已经可以使用FunctionManager了：

int add(int a, int b) { return a + b; }
void use() {
        std::function<int(int, int)> a(add);
        FunctionManager<std::function<decltype(add)>>::get_instance()->register_function("add", a);
        auto another_add = FunctionManager<std::function<decltype(add)>>::get_instance()->get_function("add");
        std::cout << another_add(1, 3) << std::endl;
}
我们看到FunctionManager的使用其实是很不方便的：

注册时需要提供对应函数的std::function对象，实际上我们在使用的时候只希望提供函数的指针
注册和获取函数时都需要需要获取单例
这些冗杂的代码可以交给单独的接口进行封装：

template <typename FunctionPtr>
void register_function(const std::string& function_sig, FunctionPtr function_ptr) {
        auto function_obj = static_cast<std::function<FunctionPtr>>(function_ptr);
        auto p_function_manager = FunctionManager<decltype(function_obj)>::get_instance();
        p_function_manager->register_function(function_sig, function_obj);
}

template <typename FunctionType>
FunctionType get_function(const std::string& function_sig) {
        auto p_function_manager = FunctionManager<FunctionType>::get_instance();
        return p_function_manager->get_function(function_sig);
}

int main(int argc, char* argv[]) {
        register_function<decltype(add)>("add", add); // 只提供指针
        auto another_add = get_function<std::function<int(int, int)>>("add");
        std::cout << another_add(1, 4) << std::endl;
        return 0;
}
相比之下使用起来方便多了，实际上到这里FunctionManager的实现就已经完成了，但是还要让FunctionManager更好用，以及让FunctionManager适用于更多类型的函数，下面才是文章的重点

注册
现有的FunctionManager如果直接使用还会存在一个问题：需要由用户保证在get_function前register_function。在demo中这并不是大问题，但是放在大型项目中，get_function在多个文件中被多次调用，需要由用户保证register_function在所有get_function前执行，这实在是太危险了。稳妥一点的方法是：

void register_all_function() {
        auto p_function_manager = /* get singleton instance */ ;
        p_function_manager->register_function(sig_1, func_1);
        p_function_manager->register_function(sig_2, func_2);
        // ...
}
int main {
        register_all_function();
}
在main最开始的时候进行注册是最安全的做法，但是每添加一个函数，用户就要在register_all_function中进行注册，这也违背了开闭原则。

因此我们有了新的需求：main函数执行前完成对象的注册。有两种方法能够在main前执行一段函数：静态成员变量和全局变量，需要注意的是二者均需要在cpp文件中定义，不能够在头文件中。通过register_function为全局变量赋值能够在main前执行register_function，因此我们还需要为register_function添加一个返回值：

template <typename FunctionPtr>
bool register_function(const std::string& function_sig, FunctionPtr function_ptr) {
        // ...
        return true;
}
用全局变量注册函数
通过定义全局变量能够在main执行前将需要的函数注册至FunctionManager。为了在使用更方便、代码可读性更高，FunctionManager提供了一个宏_REGISTER_FUNCTION，用于封装注册函数。其原理如下：

#define _REGISTER_FUNCTION(FunctionSig, FunctionPtr) \
        bool b = register_function<decltype(FunctionPtr)>(FunctionSig, FunctionPtr);
这样带来了新的问题：在实际使用时，一个.cpp文件内通常会有多个类型相同的函数的实现，_REGISTER_FUNCTION将被调用多次：

_REGISTER_FUNCTION("ADD", add);
int add(int a, int b) { return a + b; }
_REGISTER_FUNCTION("MUL", mul); // 编译错误，重复定义的变量b
int mul(int a, int b) { return a * b; }
多次调用_REGISTER_FUNCTION会导致全局变量b被重复定义。因此需要用户手动提供不重复的变量名(VariableName)以防止编译错误，最终_REGISTER_FUNCTION的实现如下：

#define _REGISTER_FUNCTION(VariableName, FunctionSig, FunctionPtr) \
        bool Bool##VariableName = register_function<decltype(FunctionPtr)>(FunctionSig, FunctionPtr);

// xxx.h
int add(int, int);
// xxx.cpp
_REGISTER_FUNCTION(ADD, "ADD", add);
int add(int a, int b) { return a + b; }
FunctionManager适配的函数
普通函数
普通函数
float add(float a, float b) { return a + b; }
_REGISTER_FUNCTION(ADD, "ADD", add);

auto new_add = get_function<decltype(add)>("ADD");
命名空间内的函数
namespace FunctionManagerTest {
    float add(float a, float b) { return a + b; }
}
_REGISTER_FUNCTION(ADD, "ADD", FunctionManagerTest::add);

auto new_add = get_function<std::function<decltype(FunctionManagerTest::add)>>("ADD");
模板函数
template<typename T> T addT(T a, T b) { return a + b; }
_REGISTER_FUNCTION(ADD, "ADD", addT<int>);

auto new_add = get_function<std::function<decltype(addT<int>)>>("ADD");
类内函数
静态函数
class Real {
public:
    static float add(float a, float b) { return a + b; }
};
_REGISTER_FUNCTION(ADD, "ADD", Real::add);

auto new_add = get_function<std::function<decltype(Real::add)>>("ADD");
模板类的静态函数
template<typename T>
class Add {
public:
    static float add(T a, T b) { return a + b; }
};
_REGISTER_FUNCTION(ADD, "ADD", Add<int>::add);

auto new_add = get_function<std::function<decltype(Add<int>::add)>>("ADD");
适配成员函数
现在的FunctionManager能够支持的函数少了很重要的一类：成员函数。因为成员函数在被调用时会有一个this指针作为隐式参数，显然直接通过&Real::add是无法获得this指针的。这意味着我们需要添加新的接口。

template<typename FunctionPtr, typename ObjectPtr>
bool register_member_function(FunctionPtr func_ptr, ObjectPtr obj_ptr) {
        return true;
}
回看需求，我们希望能够在FunctionManager中获取到函数后，能够直接调用；同时FunctionManager中管理的也只是能够直接调用的std::function对象，并未区分成员函数或者非成员函数。现在问题简化为如何为某一个函数提供一个默认的参数(对象指针)，提供后，我们就能像调用普通函数一样调用成员函数了。

我们知道std::bind能够将函数与参数绑定，返回一个Callable对象；该对象能够使用对应的std::funtion接收；结合std::placeholder还能够在调用返回的Callable时提供参数：

class Real { public: int add(int a, int b) { return a + b; } }

Real real;
std::function<int(int,int)> binded_add = std::bind(&Real::add, &real, std::placeholders::_1, std::placeholders::_2);
std::cout << binded_add(2, 1) << std::endl;
现在如何提供默认参数的问题解决了，但是另一个问题又出现了：代码中的std::function<int(int,int)>是硬编码进去的，肯定不能实装，我们需要一种能够自动填充std::function<>内模板参数的方法。在网上找了大半天后，终于有了一种基于模板的解决方案：

template <typename Ret, typename Struct, typename ...Args, typename ObjectPtr>
bool register_memeber_function(const std::string& sig, Ret(Struct::* func_ptr)(Args...) const, ObjectPtr obj_ptr) {
        std::function<Ret(Args...)> func = std::bind(func_ptr, obj_ptr);
        auto p_funciton_manager = FunctionManager<decltype(func)>::get_instance();
        p_function_manager->register_function(sig, func);
        return true;
}

class Real { public: int add(int a, int b) { return a + b; } }

Real real;
bool b = register_member_function("ADD", &Real::add, &real);
将&Real::add作为参数传入后能够自动推导出Ret, Struct以及可变参数Args；由于我们会绑定对象指针，因此我们只需要返回值Ret，参数Args作为std::function的模板参数。这样一来std::function的模板参数问题终于解决了。

然而现在的代码是无法通过编译的，因为std::bind中没有添加正确数量的std::placeholder。这个问题的解决需要用到一点元编程，StackOverflow上有人用自定义placeholder以及std::make_integer_sequence的方法来实现参数可变的std::bind：

// https://stackoverflow.com/questi ... r-of-arguments-in-c
template<int N>
struct my_placeholder { static my_placeholder ph; };

template<int N>
my_placeholder<N> my_placeholder<N>::ph;

namespace std {
    template<int N>
    struct is_placeholder<::my_placeholder<N>> : std::integral_constant<int, N> { };
}

template<class R, class T, class...Types, class U, int... indices>
std::function<R (Types...)> bind_first(std::function<R (T, Types...)> f, U val, std::integer_sequence<int, indices...> /*seq*/) {
    return std::bind(f, val, my_placeholder<indices+1>::ph...);
}
template<class R, class T, class...Types, class U>
std::function<R (Types...)> bind_first(std::function<R (T, Types...)> f, U val) {
    return bind_first(f, val, std::make_integer_sequence<int, sizeof...(Types)>());
}
这里的核心思想是在模板中传入长度与参数个数相同的整数序列，并且为每个序列中的整数添加一个placeholder。其实并不需要自己定义一个placeholder，因为std::placeholder的实现是类似的：

// PLACEHOLDER ARGUMENTS
namespace placeholders {
    _INLINE_VAR constexpr _Ph<1> _1{};
    _INLINE_VAR constexpr _Ph<2> _2{};
} // namespace placeholders
结合已有实现以及std::placeholder的解决方案如下：

template <typename Ret, typename Struct, typename ...Args, typename ObjectPtr, int... Indices>
std::function<Ret(Args...)> erase_class_info(Ret(Struct::* func_ptr)(Args...), ObjectPtr obj_ptr, std::integer_sequence<int, Indices...>)
{
        std::function<Ret(Args...)> erased_function = std::bind(func_ptr, obj_ptr, std::_Ph<Indices + 1>{}...);
        return erased_function;
}

template <typename Ret, typename Struct, typename ...Args, typename ObjectPtr>
bool register_memeber_function(const std::string& sig, Ret(Struct::* func_ptr)(Args...), ObjectPtr obj_ptr) {
        std::function<Ret(Args...)> erased_func = erase_class_info(func_ptr, obj_ptr, std::make_integer_sequence<int, sizeof...(Args)>());
        auto p_funciton_manager = FunctionManager<decltype(erased_func)>::get_instance();
        p_funciton_manager->register_function(sig, erased_func);
        return true;
}
另外，成员函数添加const以后的函数类型是不同的，简单地添加两个类似接口可以解决这个问题：

template <typename Ret, typename Struct, typename ...Args, typename ObjectPtr, int... Indices>
std::function<Ret(Args...)> erase_class_info(Ret(Struct::* func_ptr)(Args...) const, ObjectPtr obj_ptr, std::integer_sequence<int, Indices...>)
{
        std::function<Ret(Args...)> erased_function = std::bind(func_ptr, obj_ptr, std::_Ph<Indices + 1>{}...);
        return erased_function;
}

template <typename Ret, typename Struct, typename ...Args, typename ObjectPtr>
bool register_memeber_function(const std::string& sig, Ret(Struct::* func_ptr)(Args...) const, ObjectPtr obj_ptr) {
        std::function<Ret(Args...)> erased_func = erase_class_info(func_ptr, obj_ptr, std::make_integer_sequence<int, sizeof...(Args)>());
        auto p_funciton_manager = FunctionManager<decltype(erased_func)>::get_instance();
        p_funciton_manager->register_function(sig, erased_func);
        return true;
}
现在已经支持成员函数的注册了：

class Real {
public:
        int add(int a, int b) const { return a + b; }
        int sub(int a, int b) { return a - b; }
};

Real real;
bool b1 = register_memeber_function("real", &Real::add, &real);
bool b2 = register_memeber_function("REAL", &Real::sub, &real);
auto f1 = get_function<std::function<int(int, int)>>("real");
auto f2 = get_function<std::function<int(int, int)>>("REAL");
std::cout << f1(2, 1) << std::endl;
std::cout << f2(2, 1) << std::endl;
至此FunctionManager实现完成

补充
更简单的接口
前面提到了使用静态成员变量也能够实现注册功能，用静态成员变量注册函数
可以进一步减少用户需要写的代码，FunctionManager希望不需要用户提供变量名。参考boost宏BOOST_CLASS_EXPORT，其利用模板类和静态成员变量实现了类的注册，并且不需要用户提供变量名，其原理如下：

namespace boost::archive::detail::extra_detail {
    template<> struct init_guid<ClassToRegister> {
        static guid_initializer<ClassToRegister> const& g; //静态成员g
    }
    static guid_initializer<ClassToRegister> const& g = register_function(); // 定义g，同时注册类
}
BOOST_CLASS_EXPORT还是不能满足需求，因为BOOST_CLASS_EXPORT用于注册类，倘若用于注册多个相同类型的函数会导致静态成员g重复定义，而实际注册函数时同一类型的函数往往会被注册多次。如：

int add(int a, int b) { return a + b; }
int mul(int a, int b) { return a * b; }
_BOOST_LIKE_REGISTER("ADD", add);
_BOOST_LIKE_REGISTER("MUL", mul); // 静态成员g重复定义
FunctionManager通过命名空间解决重复定义这一问题，宏_EASY_REGISTER_FUNCTION实现如下：

#define _EASY_REGISTER_FUNCTION(FunctionSig, FunctionPtr) \
    namespace VicentChenSpace { \
        namespace Dummy { \
            namespace FunctionPtr { \
                struct Dummy { \
                    static bool const& b; \
                }; \
            } \
        } \
    } \
    bool const& VicentChenSpace::Dummy::FunctionPtr::Dummy::b = register_function<decltype(::FunctionPtr)>(FunctionSig, ::FunctionPtr); \
虽然_EASY_REGISTER_FUNCTION使用起来更方便，但有以下问题：

需要c++17支持
不支持注册带有模板的函数
命名空间相关问题
可运行demo
#include <functional>
#include <map>
#include <iostream>

#define _REGISTER_FUNCTION(VariableName, FunctionSig, FunctionPtr) \
        bool Bool##VariableName = register_function<decltype(FunctionPtr)>(FunctionSig, FunctionPtr);

template <typename FunctionType>
class FunctionManager {
        // 没有delete这个指针，考虑到这是demo，忽略这个问题
        inline static FunctionManager<FunctionType>* p_function_manager = nullptr;

        std::map<std::string, FunctionType> m_sig_func_map;

public:
        static FunctionManager<FunctionType>* get_instance() {
                if (!p_function_manager) p_function_manager = new FunctionManager<FunctionType>;
                return p_function_manager;
        }

        // 也可以使用insert，二者间存在一点区别
        void register_function(const std::string& sig, FunctionType function) { m_sig_func_map[sig] = function; }
       
        // 实际上不能使用运算符[]，因为当map中sig不存在时会自动创建一个<sig, empty>对象，demo中忽略这个问题
        FunctionType get_function(const std::string& sig) { return m_sig_func_map[sig]; }
};

template <typename FunctionPtr>
bool register_function(const std::string& function_sig, FunctionPtr function_ptr) {
        auto function_obj = static_cast<std::function<FunctionPtr>>(function_ptr);
        auto p_function_manager = FunctionManager<decltype(function_obj)>::get_instance();
        p_function_manager->register_function(function_sig, function_obj);
        return true;
}

template <typename FunctionType>
FunctionType get_function(const std::string& function_sig) {
        auto p_function_manager = FunctionManager<FunctionType>::get_instance();
        return p_function_manager->get_function(function_sig);
}

template <typename Ret, typename Struct, typename ...Args, typename ObjectPtr, int... Indices>
std::function<Ret(Args...)> erase_class_info(Ret(Struct::* func_ptr)(Args...), ObjectPtr obj_ptr, std::integer_sequence<int, Indices...>)
{
        std::function<Ret(Args...)> erased_function = std::bind(func_ptr, obj_ptr, std::_Ph<Indices + 1>{}...);
        return erased_function;
}

template <typename Ret, typename Struct, typename ...Args, typename ObjectPtr>
bool register_memeber_function(const std::string& sig, Ret(Struct::* func_ptr)(Args...), ObjectPtr obj_ptr) {
        std::function<Ret(Args...)> erased_func = erase_class_info(func_ptr, obj_ptr, std::make_integer_sequence<int, sizeof...(Args)>());
        auto p_funciton_manager = FunctionManager<decltype(erased_func)>::get_instance();
        p_funciton_manager->register_function(sig, erased_func);
        return true;
}

template <typename Ret, typename Struct, typename ...Args, typename ObjectPtr, int... Indices>
std::function<Ret(Args...)> erase_class_info(Ret(Struct::* func_ptr)(Args...) const, ObjectPtr obj_ptr, std::integer_sequence<int, Indices...>)
{
        std::function<Ret(Args...)> erased_function = std::bind(func_ptr, obj_ptr, std::_Ph<Indices + 1>{}...);
        return erased_function;
}

template <typename Ret, typename Struct, typename ...Args, typename ObjectPtr>
bool register_memeber_function(const std::string& sig, Ret(Struct::* func_ptr)(Args...) const, ObjectPtr obj_ptr) {
        std::function<Ret(Args...)> erased_func = erase_class_info(func_ptr, obj_ptr, std::make_integer_sequence<int, sizeof...(Args)>());
        auto p_funciton_manager = FunctionManager<decltype(erased_func)>::get_instance();
        p_funciton_manager->register_function(sig, erased_func);
        return true;
}

// ----- 普通函数注册 ----- //
// 普通函数
int add(int a, int b) { return a + b; }
_REGISTER_FUNCTION(ADD, "ADD", add);
int mul(int a, int b) { return a * b; }
_REGISTER_FUNCTION(MUL, "MUL", mul);

// 命名空间内函数
namespace VicentSpace { int add(int a, int b) { return a + b; } }
_REGISTER_FUNCTION(NAMESPACE_ADD, "NAMESPACE_ADD", VicentSpace::add);

// 模板函数
template<typename T> T addT(T a, T b) { return a + b; }
_REGISTER_FUNCTION(TEMPLATE_ADD, "TEMPLATE_ADD", addT<int>);

// ----- 类内函数注册 ----- //
class Real {
public:
        int add(int a, int b) const { return a + b; }
        int sub(int a, int b) { return a - b; }
        static int mul(int a, int b) { return a * b; }
};
Real real;

template <typename T>
class RealT {
public:
        T addT(T a, T b) const { return a + b; }
        T subT(T a, T b) { return a - b; }
        static T mulT(T a, T b) { return a * b; }
};
RealT<int> real_t;

// 静态函数
_REGISTER_FUNCTION(STATIC_MUL, "STATIC_MUL", Real::mul);

// 静态模板函数
_REGISTER_FUNCTION(STATIC_TEMPLATE_MUL, "STATIC_TEMPLATE_MUL", RealT<int>::mulT);

// 成员函数
bool b1 = register_memeber_function("REAL_ADD", &Real::add, &real);
bool b2 = register_memeber_function("REAL_SUB", &Real::sub, &real);

// 模板成员
bool b3 = register_memeber_function("REALT_ADD", &RealT<int>::addT, &real_t);
bool b4 = register_memeber_function("REALT_SUB", &RealT<int>::subT, &real_t);

int main(int argc, char* argv[]) {

        // 普通函数
        auto normal_add = get_function<std::function<decltype(add)>>("ADD");
        auto normal_mul = get_function<std::function<decltype(add)>>("MUL");
        std::cout << "Normal Add 1 + 2 = " << normal_add(1, 2) << std::endl;
        std::cout << "Normal Mul 1 * 2 = " << normal_mul(1, 2) << std::endl;

        // 命名空间内函数
        auto namespace_add = get_function<std::function<decltype(VicentSpace::add)>>("NAMESPACE_ADD");
        std::cout << "Namespace Add 1 + 2 = " << namespace_add(1, 2) << std::endl;

        // 模板函数
        auto template_add = get_function<std::function<int(int, int)>>("TEMPLATE_ADD");
        std::cout << "Template Add 1 + 2 = " << template_add(1, 2) << std::endl;

        // 静态函数
        auto static_mul = get_function<std::function<int(int, int)>>("STATIC_MUL");
        std::cout << "Static Mul 1 * 2 = " << static_mul(1, 2) << std::endl;
       
        // 静态模板函数
        auto static_template_mul = get_function<std::function<int(int, int)>>("STATIC_TEMPLATE_MUL");
        std::cout << "Static Template Mul 1 * 2 = " << static_template_mul(1, 2) << std::endl;
       
        // 成员函数
        auto real_add = get_function<std::function<int(int, int)>>("REAL_ADD");
        auto real_sub = get_function<std::function<int(int, int)>>("REAL_SUB");
        std::cout << "Member Add 2 + 1 = " << real_add(2, 1) << std::endl;
        std::cout << "Const Member Sub 2 - 1 = " << real_sub(2, 1) << std::endl;

        // 模板成员
        auto real_t_add = get_function<std::function<int(int, int)>>("REALT_ADD");
        auto real_t_sub = get_function<std::function<int(int, int)>>("REAL_SUB");
        std::cout << "Template Member Add 2 + 1 = " << real_t_add(2, 1) << std::endl;
        std::cout << "Template Const Member Sub 2 - 1 = " << real_t_sub(2, 1) << std::endl;
       
        return 0;
}

本文代码需要c++17支持(可自行修改以兼容c++11)
概述
有时候我们会对相同的数据做不同的操作，例如：

int add(int a, int b) { return a + b; }
int mul(int a, int b) { return a * b; }
int do_sth(int a, int b, const std::string& function_name) {
        if (function_name == "add") return add(a, b);
        if (function_name == "mul") return mul(a, b);
}
这种做法是可行的，但是当我们还需要添加sub(a, b)，div(a, b)等等的多个函数时，每添加一个函数，我们都要在do_sth中添加一个if，很容易出错，也不符合开闭原则。

另一种实现方法是将每个操作单独封装成一个类，然后使用工厂模式创建。这种做法是符合开闭原则的，但是每添加一个函数就要添加一个类未免也太繁琐了。

理想情况下，倘若有一门语言同时结合了c++, Java,Python，应该这样添加函数：

// 函数管理类FunctionManager
//     @Register()：将函数注册到这个类中
//     getFunction(): 将已注册的函数返回
class FunctionManager;

@Register("add") // 将函数add注册到FunctionManager，通过字符串"add"能够找到这个函数
int add(int a, int b) { return a + b; }
@Register("mul") // 将函数mul注册到FunctionManager，通过字符串"mul"能够找到这个函数
int mul(int a, int b) { return a * b; }
int do_sth(int a, int b, const std::string& function_name) {
        // 函数管理类根据function_name返回一个std::function
        std::function<int(int, int)> Function = FunctionManager.getFunction(function_name);
        return Function(a, b);
}
FunctionManager: 管理函数的类
@Register("Add"): 将函数指针和函数签名(能够唯一标识该函数的字符串)添加到FunctionManager中
FunctionManager.getFunction(): 根据函数签名返回函数指针
很明显，当前的c++不支持@Register，退而求其次我们使用宏进行注册，最终本文实现的效果是(在最后提供了可运行的完整程序)：

// xxx.h
int add(int a, int b);
// xxx.cpp
// 注册函数，参数为：变量名(ADD)，函数签名("ADD")，函数指针(add)
_REGISTER_FUNCTION(ADD, "ADD", add);
int add(int a, int b) { return a + b; }
// main.cpp
int do_sth(int a, int b, const std::string& func_sig) {
        // FunctionManager是一个单例
        auto p_function_manager = FunctionManager<decltype(add)>::getInstance();
        // 此处返回已注册的函数
        auto func = p_function_manager->getFunction(func_sig);
        return
}
实现
我们将管理函数的类命名为FunctionManager。仔细分析我们的需求，不难发现实际上我们需要根据字符串查找已注册的函数对象。

查找的实现
STL中已经有了能够满足我们需求的std::map<std::string, FunctionType>容器，因此查找功能已经实现了。需要注意的有：

FunctionType需要外部提供，而函数的返回值、参数都会改变都会影响FunctionType，我们不可能把FunctionType硬编码到程序中，这时候就需要模板。
由于函数指针不能够作为函数的返回值，获取函数的接口只能返回std::function，因此map中存储的也应当是std::function。
考虑到程序中仅有一个FunctionManager，将FunctionManager设置为单例更方便(同时也能满足注册函数的需求)。
template <typename FunctionType>
class FunctionManager {
        // 没有delete这个指针，考虑到这是demo，忽略这个问题
        inline static FunctionManager<FunctionType>* p_function_manager = nullptr;

        std::map<std::string, FunctionType> m_sig_func_map;

public:
        static FunctionManager<FunctionType>* get_instance() {
                if (!p_function_manager) p_function_manager = new FunctionManager<FunctionType>;
                return p_function_manager;
        }
       
        // 实际上不能使用运算符[]，因为当map中sig不存在时会自动创建一个<sig, empty>对象，demo中忽略这个问题
        FunctionType get_function(const std::string& sig) { return m_sig_func_map[sig]; }
};
注册的实现
注册实际上就是将函数签名(字符串)和函数(std::function对象)添加到FunctionManager::m_sig_func_map中,只需要添加一个接口：

        // 也可以使用insert，二者间存在一点区别
        void register_function(const std::string& sig, FunctionType function) { m_sig_func_map[sig] = function; }
尝试使用
到这里我们已经可以使用FunctionManager了：

int add(int a, int b) { return a + b; }
void use() {
        std::function<int(int, int)> a(add);
        FunctionManager<std::function<decltype(add)>>::get_instance()->register_function("add", a);
        auto another_add = FunctionManager<std::function<decltype(add)>>::get_instance()->get_function("add");
        std::cout << another_add(1, 3) << std::endl;
}
我们看到FunctionManager的使用其实是很不方便的：

注册时需要提供对应函数的std::function对象，实际上我们在使用的时候只希望提供函数的指针
注册和获取函数时都需要需要获取单例
这些冗杂的代码可以交给单独的接口进行封装：

template <typename FunctionPtr>
void register_function(const std::string& function_sig, FunctionPtr function_ptr) {
        auto function_obj = static_cast<std::function<FunctionPtr>>(function_ptr);
        auto p_function_manager = FunctionManager<decltype(function_obj)>::get_instance();
        p_function_manager->register_function(function_sig, function_obj);
}

template <typename FunctionType>
FunctionType get_function(const std::string& function_sig) {
        auto p_function_manager = FunctionManager<FunctionType>::get_instance();
        return p_function_manager->get_function(function_sig);
}

int main(int argc, char* argv[]) {
        register_function<decltype(add)>("add", add); // 只提供指针
        auto another_add = get_function<std::function<int(int, int)>>("add");
        std::cout << another_add(1, 4) << std::endl;
        return 0;
}
相比之下使用起来方便多了，实际上到这里FunctionManager的实现就已经完成了，但是还要让FunctionManager更好用，以及让FunctionManager适用于更多类型的函数，下面才是文章的重点

注册
现有的FunctionManager如果直接使用还会存在一个问题：需要由用户保证在get_function前register_function。在demo中这并不是大问题，但是放在大型项目中，get_function在多个文件中被多次调用，需要由用户保证register_function在所有get_function前执行，这实在是太危险了。稳妥一点的方法是：

void register_all_function() {
        auto p_function_manager = /* get singleton instance */ ;
        p_function_manager->register_function(sig_1, func_1);
        p_function_manager->register_function(sig_2, func_2);
        // ...
}
int main {
        register_all_function();
}
在main最开始的时候进行注册是最安全的做法，但是每添加一个函数，用户就要在register_all_function中进行注册，这也违背了开闭原则。

因此我们有了新的需求：main函数执行前完成对象的注册。有两种方法能够在main前执行一段函数：静态成员变量和全局变量，需要注意的是二者均需要在cpp文件中定义，不能够在头文件中。通过register_function为全局变量赋值能够在main前执行register_function，因此我们还需要为register_function添加一个返回值：

template <typename FunctionPtr>
bool register_function(const std::string& function_sig, FunctionPtr function_ptr) {
        // ...
        return true;
}
用全局变量注册函数
通过定义全局变量能够在main执行前将需要的函数注册至FunctionManager。为了在使用更方便、代码可读性更高，FunctionManager提供了一个宏_REGISTER_FUNCTION，用于封装注册函数。其原理如下：

#define _REGISTER_FUNCTION(FunctionSig, FunctionPtr) \
        bool b = register_function<decltype(FunctionPtr)>(FunctionSig, FunctionPtr);
这样带来了新的问题：在实际使用时，一个.cpp文件内通常会有多个类型相同的函数的实现，_REGISTER_FUNCTION将被调用多次：

_REGISTER_FUNCTION("ADD", add);
int add(int a, int b) { return a + b; }
_REGISTER_FUNCTION("MUL", mul); // 编译错误，重复定义的变量b
int mul(int a, int b) { return a * b; }
多次调用_REGISTER_FUNCTION会导致全局变量b被重复定义。因此需要用户手动提供不重复的变量名(VariableName)以防止编译错误，最终_REGISTER_FUNCTION的实现如下：

#define _REGISTER_FUNCTION(VariableName, FunctionSig, FunctionPtr) \
        bool Bool##VariableName = register_function<decltype(FunctionPtr)>(FunctionSig, FunctionPtr);

// xxx.h
int add(int, int);
// xxx.cpp
_REGISTER_FUNCTION(ADD, "ADD", add);
int add(int a, int b) { return a + b; }
FunctionManager适配的函数
普通函数
普通函数
float add(float a, float b) { return a + b; }
_REGISTER_FUNCTION(ADD, "ADD", add);

auto new_add = get_function<decltype(add)>("ADD");
命名空间内的函数
namespace FunctionManagerTest {
    float add(float a, float b) { return a + b; }
}
_REGISTER_FUNCTION(ADD, "ADD", FunctionManagerTest::add);

auto new_add = get_function<std::function<decltype(FunctionManagerTest::add)>>("ADD");
模板函数
template<typename T> T addT(T a, T b) { return a + b; }
_REGISTER_FUNCTION(ADD, "ADD", addT<int>);

auto new_add = get_function<std::function<decltype(addT<int>)>>("ADD");
类内函数
静态函数
class Real {
public:
    static float add(float a, float b) { return a + b; }
};
_REGISTER_FUNCTION(ADD, "ADD", Real::add);

auto new_add = get_function<std::function<decltype(Real::add)>>("ADD");
模板类的静态函数
template<typename T>
class Add {
public:
    static float add(T a, T b) { return a + b; }
};
_REGISTER_FUNCTION(ADD, "ADD", Add<int>::add);

auto new_add = get_function<std::function<decltype(Add<int>::add)>>("ADD");
适配成员函数
现在的FunctionManager能够支持的函数少了很重要的一类：成员函数。因为成员函数在被调用时会有一个this指针作为隐式参数，显然直接通过&Real::add是无法获得this指针的。这意味着我们需要添加新的接口。

template<typename FunctionPtr, typename ObjectPtr>
bool register_member_function(FunctionPtr func_ptr, ObjectPtr obj_ptr) {
        return true;
}
回看需求，我们希望能够在FunctionManager中获取到函数后，能够直接调用；同时FunctionManager中管理的也只是能够直接调用的std::function对象，并未区分成员函数或者非成员函数。现在问题简化为如何为某一个函数提供一个默认的参数(对象指针)，提供后，我们就能像调用普通函数一样调用成员函数了。

我们知道std::bind能够将函数与参数绑定，返回一个Callable对象；该对象能够使用对应的std::funtion接收；结合std::placeholder还能够在调用返回的Callable时提供参数：

class Real { public: int add(int a, int b) { return a + b; } }

Real real;
std::function<int(int,int)> binded_add = std::bind(&Real::add, &real, std::placeholders::_1, std::placeholders::_2);
std::cout << binded_add(2, 1) << std::endl;
现在如何提供默认参数的问题解决了，但是另一个问题又出现了：代码中的std::function<int(int,int)>是硬编码进去的，肯定不能实装，我们需要一种能够自动填充std::function<>内模板参数的方法。在网上找了大半天后，终于有了一种基于模板的解决方案：

template <typename Ret, typename Struct, typename ...Args, typename ObjectPtr>
bool register_memeber_function(const std::string& sig, Ret(Struct::* func_ptr)(Args...) const, ObjectPtr obj_ptr) {
        std::function<Ret(Args...)> func = std::bind(func_ptr, obj_ptr);
        auto p_funciton_manager = FunctionManager<decltype(func)>::get_instance();
        p_function_manager->register_function(sig, func);
        return true;
}

class Real { public: int add(int a, int b) { return a + b; } }

Real real;
bool b = register_member_function("ADD", &Real::add, &real);
将&Real::add作为参数传入后能够自动推导出Ret, Struct以及可变参数Args；由于我们会绑定对象指针，因此我们只需要返回值Ret，参数Args作为std::function的模板参数。这样一来std::function的模板参数问题终于解决了。

然而现在的代码是无法通过编译的，因为std::bind中没有添加正确数量的std::placeholder。这个问题的解决需要用到一点元编程，StackOverflow上有人用自定义placeholder以及std::make_integer_sequence的方法来实现参数可变的std::bind：

// https://stackoverflow.com/questi ... r-of-arguments-in-c
template<int N>
struct my_placeholder { static my_placeholder ph; };

template<int N>
my_placeholder<N> my_placeholder<N>::ph;

namespace std {
    template<int N>
    struct is_placeholder<::my_placeholder<N>> : std::integral_constant<int, N> { };
}

template<class R, class T, class...Types, class U, int... indices>
std::function<R (Types...)> bind_first(std::function<R (T, Types...)> f, U val, std::integer_sequence<int, indices...> /*seq*/) {
    return std::bind(f, val, my_placeholder<indices+1>::ph...);
}
template<class R, class T, class...Types, class U>
std::function<R (Types...)> bind_first(std::function<R (T, Types...)> f, U val) {
    return bind_first(f, val, std::make_integer_sequence<int, sizeof...(Types)>());
}
这里的核心思想是在模板中传入长度与参数个数相同的整数序列，并且为每个序列中的整数添加一个placeholder。其实并不需要自己定义一个placeholder，因为std::placeholder的实现是类似的：

// PLACEHOLDER ARGUMENTS
namespace placeholders {
    _INLINE_VAR constexpr _Ph<1> _1{};
    _INLINE_VAR constexpr _Ph<2> _2{};
} // namespace placeholders
结合已有实现以及std::placeholder的解决方案如下：

template <typename Ret, typename Struct, typename ...Args, typename ObjectPtr, int... Indices>
std::function<Ret(Args...)> erase_class_info(Ret(Struct::* func_ptr)(Args...), ObjectPtr obj_ptr, std::integer_sequence<int, Indices...>)
{
        std::function<Ret(Args...)> erased_function = std::bind(func_ptr, obj_ptr, std::_Ph<Indices + 1>{}...);
        return erased_function;
}

template <typename Ret, typename Struct, typename ...Args, typename ObjectPtr>
bool register_memeber_function(const std::string& sig, Ret(Struct::* func_ptr)(Args...), ObjectPtr obj_ptr) {
        std::function<Ret(Args...)> erased_func = erase_class_info(func_ptr, obj_ptr, std::make_integer_sequence<int, sizeof...(Args)>());
        auto p_funciton_manager = FunctionManager<decltype(erased_func)>::get_instance();
        p_funciton_manager->register_function(sig, erased_func);
        return true;
}
另外，成员函数添加const以后的函数类型是不同的，简单地添加两个类似接口可以解决这个问题：

template <typename Ret, typename Struct, typename ...Args, typename ObjectPtr, int... Indices>
std::function<Ret(Args...)> erase_class_info(Ret(Struct::* func_ptr)(Args...) const, ObjectPtr obj_ptr, std::integer_sequence<int, Indices...>)
{
        std::function<Ret(Args...)> erased_function = std::bind(func_ptr, obj_ptr, std::_Ph<Indices + 1>{}...);
        return erased_function;
}

template <typename Ret, typename Struct, typename ...Args, typename ObjectPtr>
bool register_memeber_function(const std::string& sig, Ret(Struct::* func_ptr)(Args...) const, ObjectPtr obj_ptr) {
        std::function<Ret(Args...)> erased_func = erase_class_info(func_ptr, obj_ptr, std::make_integer_sequence<int, sizeof...(Args)>());
        auto p_funciton_manager = FunctionManager<decltype(erased_func)>::get_instance();
        p_funciton_manager->register_function(sig, erased_func);
        return true;
}
现在已经支持成员函数的注册了：

class Real {
public:
        int add(int a, int b) const { return a + b; }
        int sub(int a, int b) { return a - b; }
};

Real real;
bool b1 = register_memeber_function("real", &Real::add, &real);
bool b2 = register_memeber_function("REAL", &Real::sub, &real);
auto f1 = get_function<std::function<int(int, int)>>("real");
auto f2 = get_function<std::function<int(int, int)>>("REAL");
std::cout << f1(2, 1) << std::endl;
std::cout << f2(2, 1) << std::endl;
至此FunctionManager实现完成

补充
更简单的接口
前面提到了使用静态成员变量也能够实现注册功能，用静态成员变量注册函数
可以进一步减少用户需要写的代码，FunctionManager希望不需要用户提供变量名。参考boost宏BOOST_CLASS_EXPORT，其利用模板类和静态成员变量实现了类的注册，并且不需要用户提供变量名，其原理如下：

namespace boost::archive::detail::extra_detail {
    template<> struct init_guid<ClassToRegister> {
        static guid_initializer<ClassToRegister> const& g; //静态成员g
    }
    static guid_initializer<ClassToRegister> const& g = register_function(); // 定义g，同时注册类
}
BOOST_CLASS_EXPORT还是不能满足需求，因为BOOST_CLASS_EXPORT用于注册类，倘若用于注册多个相同类型的函数会导致静态成员g重复定义，而实际注册函数时同一类型的函数往往会被注册多次。如：

int add(int a, int b) { return a + b; }
int mul(int a, int b) { return a * b; }
_BOOST_LIKE_REGISTER("ADD", add);
_BOOST_LIKE_REGISTER("MUL", mul); // 静态成员g重复定义
FunctionManager通过命名空间解决重复定义这一问题，宏_EASY_REGISTER_FUNCTION实现如下：

#define _EASY_REGISTER_FUNCTION(FunctionSig, FunctionPtr) \
    namespace VicentChenSpace { \
        namespace Dummy { \
            namespace FunctionPtr { \
                struct Dummy { \
                    static bool const& b; \
                }; \
            } \
        } \
    } \
    bool const& VicentChenSpace::Dummy::FunctionPtr::Dummy::b = register_function<decltype(::FunctionPtr)>(FunctionSig, ::FunctionPtr); \
虽然_EASY_REGISTER_FUNCTION使用起来更方便，但有以下问题：

需要c++17支持
不支持注册带有模板的函数
命名空间相关问题
可运行demo
#include <functional>
#include <map>
#include <iostream>

#define _REGISTER_FUNCTION(VariableName, FunctionSig, FunctionPtr) \
        bool Bool##VariableName = register_function<decltype(FunctionPtr)>(FunctionSig, FunctionPtr);

template <typename FunctionType>
class FunctionManager {
        // 没有delete这个指针，考虑到这是demo，忽略这个问题
        inline static FunctionManager<FunctionType>* p_function_manager = nullptr;

        std::map<std::string, FunctionType> m_sig_func_map;

public:
        static FunctionManager<FunctionType>* get_instance() {
                if (!p_function_manager) p_function_manager = new FunctionManager<FunctionType>;
                return p_function_manager;
        }

        // 也可以使用insert，二者间存在一点区别
        void register_function(const std::string& sig, FunctionType function) { m_sig_func_map[sig] = function; }
       
        // 实际上不能使用运算符[]，因为当map中sig不存在时会自动创建一个<sig, empty>对象，demo中忽略这个问题
        FunctionType get_function(const std::string& sig) { return m_sig_func_map[sig]; }
};

template <typename FunctionPtr>
bool register_function(const std::string& function_sig, FunctionPtr function_ptr) {
        auto function_obj = static_cast<std::function<FunctionPtr>>(function_ptr);
        auto p_function_manager = FunctionManager<decltype(function_obj)>::get_instance();
        p_function_manager->register_function(function_sig, function_obj);
        return true;
}

template <typename FunctionType>
FunctionType get_function(const std::string& function_sig) {
        auto p_function_manager = FunctionManager<FunctionType>::get_instance();
        return p_function_manager->get_function(function_sig);
}

template <typename Ret, typename Struct, typename ...Args, typename ObjectPtr, int... Indices>
std::function<Ret(Args...)> erase_class_info(Ret(Struct::* func_ptr)(Args...), ObjectPtr obj_ptr, std::integer_sequence<int, Indices...>)
{
        std::function<Ret(Args...)> erased_function = std::bind(func_ptr, obj_ptr, std::_Ph<Indices + 1>{}...);
        return erased_function;
}

template <typename Ret, typename Struct, typename ...Args, typename ObjectPtr>
bool register_memeber_function(const std::string& sig, Ret(Struct::* func_ptr)(Args...), ObjectPtr obj_ptr) {
        std::function<Ret(Args...)> erased_func = erase_class_info(func_ptr, obj_ptr, std::make_integer_sequence<int, sizeof...(Args)>());
        auto p_funciton_manager = FunctionManager<decltype(erased_func)>::get_instance();
        p_funciton_manager->register_function(sig, erased_func);
        return true;
}

template <typename Ret, typename Struct, typename ...Args, typename ObjectPtr, int... Indices>
std::function<Ret(Args...)> erase_class_info(Ret(Struct::* func_ptr)(Args...) const, ObjectPtr obj_ptr, std::integer_sequence<int, Indices...>)
{
        std::function<Ret(Args...)> erased_function = std::bind(func_ptr, obj_ptr, std::_Ph<Indices + 1>{}...);
        return erased_function;
}

template <typename Ret, typename Struct, typename ...Args, typename ObjectPtr>
bool register_memeber_function(const std::string& sig, Ret(Struct::* func_ptr)(Args...) const, ObjectPtr obj_ptr) {
        std::function<Ret(Args...)> erased_func = erase_class_info(func_ptr, obj_ptr, std::make_integer_sequence<int, sizeof...(Args)>());
        auto p_funciton_manager = FunctionManager<decltype(erased_func)>::get_instance();
        p_funciton_manager->register_function(sig, erased_func);
        return true;
}

// ----- 普通函数注册 ----- //
// 普通函数
int add(int a, int b) { return a + b; }
_REGISTER_FUNCTION(ADD, "ADD", add);
int mul(int a, int b) { return a * b; }
_REGISTER_FUNCTION(MUL, "MUL", mul);

// 命名空间内函数
namespace VicentSpace { int add(int a, int b) { return a + b; } }
_REGISTER_FUNCTION(NAMESPACE_ADD, "NAMESPACE_ADD", VicentSpace::add);

// 模板函数
template<typename T> T addT(T a, T b) { return a + b; }
_REGISTER_FUNCTION(TEMPLATE_ADD, "TEMPLATE_ADD", addT<int>);

// ----- 类内函数注册 ----- //
class Real {
public:
        int add(int a, int b) const { return a + b; }
        int sub(int a, int b) { return a - b; }
        static int mul(int a, int b) { return a * b; }
};
Real real;

template <typename T>
class RealT {
public:
        T addT(T a, T b) const { return a + b; }
        T subT(T a, T b) { return a - b; }
        static T mulT(T a, T b) { return a * b; }
};
RealT<int> real_t;

// 静态函数
_REGISTER_FUNCTION(STATIC_MUL, "STATIC_MUL", Real::mul);

// 静态模板函数
_REGISTER_FUNCTION(STATIC_TEMPLATE_MUL, "STATIC_TEMPLATE_MUL", RealT<int>::mulT);

// 成员函数
bool b1 = register_memeber_function("REAL_ADD", &Real::add, &real);
bool b2 = register_memeber_function("REAL_SUB", &Real::sub, &real);

// 模板成员
bool b3 = register_memeber_function("REALT_ADD", &RealT<int>::addT, &real_t);
bool b4 = register_memeber_function("REALT_SUB", &RealT<int>::subT, &real_t);

int main(int argc, char* argv[]) {

        // 普通函数
        auto normal_add = get_function<std::function<decltype(add)>>("ADD");
        auto normal_mul = get_function<std::function<decltype(add)>>("MUL");
        std::cout << "Normal Add 1 + 2 = " << normal_add(1, 2) << std::endl;
        std::cout << "Normal Mul 1 * 2 = " << normal_mul(1, 2) << std::endl;

        // 命名空间内函数
        auto namespace_add = get_function<std::function<decltype(VicentSpace::add)>>("NAMESPACE_ADD");
        std::cout << "Namespace Add 1 + 2 = " << namespace_add(1, 2) << std::endl;

        // 模板函数
        auto template_add = get_function<std::function<int(int, int)>>("TEMPLATE_ADD");
        std::cout << "Template Add 1 + 2 = " << template_add(1, 2) << std::endl;

        // 静态函数
        auto static_mul = get_function<std::function<int(int, int)>>("STATIC_MUL");
        std::cout << "Static Mul 1 * 2 = " << static_mul(1, 2) << std::endl;
       
        // 静态模板函数
        auto static_template_mul = get_function<std::function<int(int, int)>>("STATIC_TEMPLATE_MUL");
        std::cout << "Static Template Mul 1 * 2 = " << static_template_mul(1, 2) << std::endl;
       
        // 成员函数
        auto real_add = get_function<std::function<int(int, int)>>("REAL_ADD");
        auto real_sub = get_function<std::function<int(int, int)>>("REAL_SUB");
        std::cout << "Member Add 2 + 1 = " << real_add(2, 1) << std::endl;
        std::cout << "Const Member Sub 2 - 1 = " << real_sub(2, 1) << std::endl;

        // 模板成员
        auto real_t_add = get_function<std::function<int(int, int)>>("REALT_ADD");
        auto real_t_sub = get_function<std::function<int(int, int)>>("REAL_SUB");
        std::cout << "Template Member Add 2 + 1 = " << real_t_add(2, 1) << std::endl;
        std::cout << "Template Const Member Sub 2 - 1 = " << real_t_sub(2, 1) << std::endl;
       
        return 0;
}