Создать класс, в котором можно сохранить любой вызываемый объект или функцию

#include <iostream>
#include <string>
#include <memory>
#include <vector>
#include <boost/type_traits/function_traits.hpp>
 
class function_wrapper
{
   struct base_holder
   {
      virtual ~base_holder() {}
 
      template <typename... Args>
      return_type call(Args&&... args) const = 0;
   };
 
   template <typename F>
   struct func_holder : base_holder
   {
      F f;
      func_holder(F&& f_) : f(std::move(f_)) {}
 
      template <typename... Args>
      return_type call(Args&&... args) const
      {
         return f(std::forward<Args>(args)...);
      }
   };
 
   std::shared_ptr<base_holder> holder;
 
public:
   template <typename T>
   explicit function_wrapper(T&& t) : holder(new func_holder<T>(std::forward<T>(t)))
   {
      //этот тип надо както сохранить и использовать в качестве возвращаемого
      //типа в operator()
      typedef typename boost::function_traits<T>::result_type return_type;
   }
 
   template <typename... Args>
   return_type operator ()(Args&&... args) const
   {
      return holder->call(std::forward<Args>(args)...);
   }
};
 
////////////////////////////////////////////////////////////////////////////////
 
void foo1(const std::string& s, int val)
{
   std::cout << s << " " << val << "\n";
}
 
int foo2(const std::string& s, int val)
{
   std::cout << s << "\n";
   return val;
}
 
int main()
{
   std::vector<function_wrapper> fw;
   fw.push_back(function_wrapper(foo1));
   fw.push_back(function_wrapper(foo2));
 
   std::cout << fw[0]("return void", 100);
   auto val = fw[1]("return int", 10);
   std::cout << val << "\n";
 
   std::cout << "Bye... :-) \n\n";
   return 0;
}

   struct base_holder
   {
      virtual ~base_holder() {}
 
      template <typename... Args>
      return_type call(Args&&... args) const = 0;
   };