#include <iostream>
#include <tuple>
#include <string>
#include <vector>
#include <boost/any.hpp>
 
// helper function to print a tuple of any size
template<class Tuple, std::size_t N>
struct TuplePrinter {
    static void print(const Tuple& t) 
    {
        TuplePrinter<Tuple, N-1>::print(t);
        std::cout << ", " << std::get<N-1>(t);
    }
};
 
template<class Tuple>
struct TuplePrinter<Tuple, 1> {
    static void print(const Tuple& t) 
    {
        std::cout << std::get<0>(t);
    }
};
 
template<class... Args>
void print(const std::tuple<Args...>& t) 
{
    std::cout << "(";
    TuplePrinter<decltype(t), sizeof...(Args)>::print(t);
    std::cout << ")\n";
}
// end helper function


// template <class T0, std::size_t I0, class... Types, std::size_t... Is>
// auto v2t(std::vector<int>& in){
//     return std::tuple_cat(v2t);
// }

// template <class T0, std::size_t I0>
// auto v2t(std::vector<int>& in){
//     return std::make_tuple(T0(in[I0]));
// }

struct Foo{
    Foo(const int &a) : x(a) {};
    int x;
};

struct Bar : public Foo{
    Bar(const int &a) : Foo(a) {};
};

 
int main()
{
    auto a = Bar(97);
    std::cout << "a: " << typeid(a).name() << ", " << a.x << std::endl;
   
    auto b = boost::any(&a);
    std::cout << "b: " << typeid(b).name() << ", " << b.type().name() << std::endl;
    
    auto c = boost::any_cast<Foo*>(b);
    std::cout << "c: " << typeid(c).name() << std::endl;

}