namespace detail
{
    template<size_t i,typename... types>
    struct get_variadic_type;
    template<size_t i,typename cur_t,typename... types>
    struct get_variadic_type<i,cur_t,types...>
    {
        typedef typename get_variadic_type<i-1,types...>::current_type current_type;
    };
    template<typename cur_t,typename... types>
    struct get_variadic_type<0,cur_t,types...>
    {
        typedef cur_t current_type;
    };
}


template<size_t i,typename... types>
struct create_item_impl
{
    typedef typename detail::get_variadic_type<i,types...>::current_type type;
    template<typename... targs_t>
    static void* create(const char *str,targs_t ...args)
    {
        if(strcmp(type::name,str)==0)
        {
            return new type(args...);
        }
        else
        {
            return create_item_impl<i-1,types...>::create(str,args...);
        }
    }
};
template<typename... types>
struct create_item_impl<0,types...>
{
    typedef typename detail::get_variadic_type<0,types...>::current_type type;
    template<typename... targs_t>
    static void* create(const char *str,targs_t ...args)
    {
        if(strcmp(type::name,str)==0)
        {
            return  new type(args...);
        }
        else
        {
            return nullptr;
        }
    }
};

template<typename... types>
struct create_item
{
    enum {size = sizeof...(types)-1};
    template<typename... targs_t>
    static void* create(const char *str,targs_t ...args)
    {
        return create_item_impl<size,types...>::create(str,args...);
    }
};
template<typename type_t>
struct factory_item
{
    static constexpr const char * name = "unknown";
};
struct A:public factory_item<A>
{
    static constexpr const char * name = "A";
    A(const std::string &val)
    {

    }
    void foo(){}
};
struct B:public factory_item<B>
{
    static constexpr const char * name = "B";
    B(const std::string &val)
    {

    }
    void foo(){}
};
struct C:public factory_item<C>
{
    static constexpr const char * name = "C";
    C(const std::string &val)
    {

    }
    void foo(){}
};

template<typename... types>
struct static_factory
{
    template<typename... targs_t>
    void* find_and_create(const char * val,targs_t ...args)
    {
        return create_item<types...>::create(val,args...);
    }
};


int main(int argc, char* argv[])
{
   static_factory<A,C,B > fac;
   void *ret= fac.find_and_create("A","S"); // надо бы вызвать foo
  return 0;
}

template<typename... Types>
struct Foo
{
    // Forward declaration
    template<int id, typename... Types_>
    struct X;
 
    // Declaration
    template<int id, typename First, typename... Types_>
    struct X<id, First, Types_...>: X<id - 1, Types_...>
    {
    };
 
    // Specialized
    template<typename First, typename... Types_>
    struct X<0, First, Types_...>
    {
        typedef First DataType;
    };
 
    // Preferable (template aliases) way but we have to wait for GCC 4.7
    // template<int id>
    // using DataType = X<id, Types...>::DataType;
 
    template<int id>
    struct Y
    {
        typedef typename X<id, Types...>::DataType DataType;
    };
};
 
int main(int, char**)
{
    typedef Foo<double, int, std::string> MyFoo;
    MyFoo::Y<0>::DataType a(1.23);
    MyFoo::Y<1>::DataType b(123);
    MyFoo::Y<2>::DataType c("Hello");
 
    std::cout << a << " " << b << " " << c << std::endl;
}

template<typename impl>
struct base
{
void foo()
{
  impl_.foo();
}
  impl impl_;
};
struct A
{
void foo(){}
}
struct B
{
void foo(){}
}
template<typename type_t>
void do_foo(base<type_t> &imp)
{
imp.foo();
}
main()
{
base<A> a;
base<B> b;
do_foo(a);
do_foo(b);
}

template<typename derived_t>
struct base 
{
void foo()
{
  return static_cast<derived*>(this)->foo();
}
};
struct A : public base<A>
{
void foo(){}
}
struct B: public base<B>
{
void foo(){}
}
template<typename type_t>
void do_foo(base<type_t> &imp)
{
imp.foo();
}
main()
{
A a;
B b;
do_foo(a);
do_foo(b);
}

main()
{
    A a;
    B b;
    a.foo();
    b.foo();
}

template<typename derived_t>
struct base