Thread: C++11 Args...

I've been reading about variadic templates, but having a hard time wrapping my mind around them.

The following code is from:

c++ - Call function with parameters extracted from string - Stack Overflow

Is it possible to do something like this with a string array, string vector, stringstream, or something to that effect instead of with an istream? istreams don't fit my usage. id like to pass in a string and split argument by spaces.

Can anyone point me in the right direction?

Code:

#include <map>
#include <string>
#include <iostream>
#include <sstream>
#include <functional>
#include <stdexcept>
#include <type_traits>


template<class F>
struct stream_function;


template<class R, class... Args>
struct stream_function<R(Args...)>{
  typedef R func_type(Args...);
  typedef std::function<func_type> function;
  static unsigned const arity = sizeof...(Args);


  template<class F>
  stream_function(F const& f)
    : _f(f) {}


  void operator()(std::istream& args, std::string* out_opt) const{
    call(args, out_opt, typename std::is_void<R>::type());
  }


private:  
  template<class T>
  static T get(std::istream& args){
    T t; // must be default constructible
    if(!(args >> t)){
      args.clear();
      throw std::invalid_argument("invalid argument to stream_function");
    }
    return t;
  }


  void call(std::istream& args, std::string*, std::true_type) const{
    // void return
    _f(get<Args>(args)...);
  }


  void call(std::istream& args, std::string* out_opt, std::false_type) const{
    // non-void return
    if(!out_opt) // no return wanted, redirect
      return call(args, 0, std::true_type());


    R ret(_f(get<Args>(args)...));
    std::stringstream conv;
    if(!(conv << ret))
      throw std::runtime_error("bad return in stream_function");
    *out_opt = conv.str();
  }


  function _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 main(){
  dict_type func_dict;
  func_dict["print"] = stream_function<void()>(print);
  func_dict["add"] = stream_function<int(int,int)>(add);


  for(;;){
    std::cout << "Which function should be called?\n";
    std::string tmp;
    std::cin >> tmp;
    auto it = func_dict.find(tmp);
    if(it == func_dict.end()){
      std::cout << "Invalid function '" << tmp << "'\n";
      continue;
    }
    tmp.clear();
    try{
      it->second(std::cin, &tmp);
    }catch(std::exception const& e){
      std::cout << "Error: '" << e.what() << "'\n";
      std::cin.ignore();
      continue;
    }
    std::cout << "Result: " << (tmp.empty()? "none" : tmp) << '\n';
  }
}