Вычисление арифметического выражения заданного в виде строки

string s = '+';

#include <iostream>
#include <map>
#include <functional>
 
namespace detail
{
#define GENERATE_ARITHMETICK(name, op) \
    template<typename T1, typename T2> \
    std::common_type_t<T1, T2> name(const T1 & t1, const T2 & t2) \
    { return t1 op t2; }
 
GENERATE_ARITHMETICK(plus, +)
GENERATE_ARITHMETICK(minus, -)
GENERATE_ARITHMETICK(devide, /)
GENERATE_ARITHMETICK(multiple, *)
    
#undef GENERATE_ARITHMETICK
}
 
template<typename T1, typename T2>
std::common_type_t<T1, T2> operatorDepedencer(const T1 & t1, const T2 & t2, char op)
{
    static std::map<char, std::function<std::common_type_t<T1, T2>(const T1 &, const T2 &)>> funcMap
    {
        { '+', detail::plus<T1, T2> },
        { '-', detail::minus<T1, T2> },
        { '/', detail::devide<T1, T2> },
        { '*', detail::multiple<T1, T2> }
    };
    
    return funcMap[op](t1, t2);
}
 
int main()
{
    std::cout << operatorDepedencer(1, 2, '+') << "\n";
    std::cout << operatorDepedencer(1, 2, '-') << "\n";
    std::cout << operatorDepedencer(1, 2, '*') << "\n";
    std::cout << operatorDepedencer(1, 2., '/') << "\n";
}

#include <iostream>
#include <map>
#include <functional>
 
namespace detail
{
// обьявляем макрос для генерации функций арифметических преобразований
// в него передаём имя операции и сам оператор
#define GENERATE_ARITHMETICK(name, op) \
    template<typename T1, typename T2> \
    std::common_type_t<T1, T2> name(const T1 & t1, const T2 & t2) \
    { return t1 op t2; }
 
// генерирум 4 основных арифметических операции
GENERATE_ARITHMETICK(plus, +)
GENERATE_ARITHMETICK(minus, -)
GENERATE_ARITHMETICK(devide, /)
GENERATE_ARITHMETICK(multiple, *)
    
// макрос нам больше не нужен, андефаем его
#undef GENERATE_ARITHMETICK
}
 
template<typename T1, typename T2>
std::common_type_t<T1, T2> operatorDepedencer(const T1 & t1, const T2 & t2, char op)
{
    //объявляем статическую мапу для того, чтобы выбирать операцию в зависимости от переданного оператора
    static std::map<char, std::function<std::common_type_t<T1, T2>(const T1 &, const T2 &)>> funcMap
    {
        { '+', detail::plus<T1, T2> },
        { '-', detail::minus<T1, T2> },
        { '/', detail::devide<T1, T2> },
        { '*', detail::multiple<T1, T2> }
    };
    
    return funcMap[op](t1, t2);
}
 
int main()
{
    std::cout << operatorDepedencer(1, 2, '+') << "\n";
    std::cout << operatorDepedencer(1, 2, '-') << "\n";
    std::cout << operatorDepedencer(1, 2, '*') << "\n";
    std::cout << operatorDepedencer(1, 2., '/') << "\n";
}

#include <iostream>
 
template <class T> struct PlusPolicy {
    static T action(T first, T second) {
        return first + second;
    }
};
 
template <class T> struct MinusPolicy {
    static T action(T first, T second) {
        return first - second;
    }
};
 
template <class T> struct MultiplyPolicy {
    static T action(T first, T second) {
        return first * second;
    }
};
 
template <class T> struct DevidePolicy {
    static T action(T first, T second) {
        return first / second;
    }
};
 
template<char> struct Action;
 
template<> struct Action<'+'> : public PlusPolicy<int> {};
template<> struct Action<'-'> : public MinusPolicy<int> {};
template<> struct Action<'*'> : public MultiplyPolicy<int> {};
template<> struct Action<'/'> : public DevidePolicy<int> {};
 
int main(int argc, char* arhv[]) {
 
    //OK
    std::cout << Action<'+'>::action(1, 2) << std::endl;
    std::cout << Action<'-'>::action(1, 2) << std::endl;
    std::cout << Action<'*'>::action(1, 2) << std::endl;
    std::cout << Action<'/'>::action(10, 2) << std::endl;
 
    //Compile time error
    std::cout << Action<'&'>::action(1, 2) << std::endl;
 
    std::cin.ignore();
    return EXIT_SUCCESS;
}

typedef Action<'+'> Plus;
typedef Action<'-'> Minus;
typedef Action<'*'> Multiply;
typedef Action<'/'> Devide;