Работа с аргументами консоли

#include <map>
#include <string>
#include <iostream>
#include <sstream>
#include <functional>
#include <stdexcept>
#include <type_traits>
 
//-----------------------------------------------------------------------------------------//
 
    template<class Sig, class F>
        struct stream_function_;
 
    template<class R, class... Args, class F>
    struct stream_function_<R(Args...), F>
    {
        stream_function_(F f)
            : _f(f) 
        {}
 
        void operator()(std::istream& args, std::string* out_opt)const
            { call<R>(args, out_opt); }
 
    private:
        template<class T> static T get(std::istream& args)
        {
            T t; 
            if( !(args >> t) )
                args.clear(),
                throw std::invalid_argument("invalid argument to stream_function");
 
            return t;
        }
 
        #define dIS_VOID \
            std::is_same<U, void>::value
        #define dVOID    \
            typename std::enable_if<dIS_VOID, U>::type* = nullptr
        #define dRETURN  \
            typename std::enable_if<!dIS_VOID,U>::type* = nullptr
 
        template<class U, dVOID>
        void call(std::istream& args, std::string*) const
        {
            (void)args;
            _f( std::forward<Args>(get<Args>(args))... );
        }
 
        template<class U, dRETURN>
        void call(std::istream& args, std::string* out_opt) const
        {
            if(!out_opt) 
                return call<void>(args, nullptr);
 
            std::stringstream conv;
            conv << _f( std::forward<Args>(get<Args>(args))... );
            if(!conv)
                throw std::runtime_error("bad return in stream_function");
 
            *out_opt = conv.str();
        }
        #undef dIS_VOID 
        #undef dRETURN
        #undef dVOID
 
        F _f;
    };
 
    template<class Sig, class F>
    stream_function_<Sig, F> 
        stream_function(F f){ return f; }
 
    typedef std::function<void(std::istream&, std::string*)> 
        func_type;
    typedef std::map<std::string, func_type> 
        dict_type;
 
 
//-----------------------------------------------------------------------------------------//
 
void print(){ std::cout << "print()\n"; }
 
int add(int a, int b){ return a + b; }
int sub(int a, int b){ return a - b; }
 
 
int main()
{
    dict_type func_dict;
    func_dict["print"] = stream_function<void()>(print);
    func_dict["add"]   = stream_function<int(int,int)>(add);
    func_dict["sub"]   = stream_function<int(int,int)>(sub);
 
    std::cout << "[ functions binded ]\n";
    for(const auto& i: func_dict)
        std::cout << " --- " << i.first<<'\n';
 
    std::cout << " enter 'exit' to exit\n";
 
    for(;;)
    {
        std::cout << "Which function should be called?\n";
        std::string tmp;
        std::cin >> tmp;
        
        std::cout << "selected: "<<tmp<<'\n';
 
        if(tmp=="exit")
            break;
 
        const auto it = func_dict.find(tmp);
 
        if(it == func_dict.end()){
            std::cout << "Invalid function '" << tmp << "'\n";
            continue;
        }
 
        try{
            std::string result;
            it->second(std::cin, &result);
            std::cout << "Result: " << (result.empty()? "none" : result) << '\n';
        }
        catch(std::exception const& e){
            std::cout << "Error: '" << e.what() << "'\n";
            std::cin.ignore();
            continue;
        }
        
    }
}

#include <iostream>
 
int main()
{
   std::cout << "3" << endl;
return 0;
}