fork download

copy

#include <memory>
 
template<class...Ts>struct types:std::integral_constant<unsigned,sizeof...(Ts)>
{typedef types type;};
template<class T,class types>struct index_of;
template<class T,class T0, class...Ts>struct index_of<T,types<T0,Ts...>>:
  std::integral_constant<unsigned,index_of<T,types<Ts...>>::value+1>
{};
template<class T,class...Ts>struct index_of<T,types<T,Ts...>>:
  std::integral_constant<unsigned,0>
{};
template<unsigned,class types>struct type_at;
template<unsigned N, class T,class...Ts>struct type_at<N,types<T,Ts...>>:
  type_at<N-1,types<Ts...>> {};
template<class T,class...Ts>struct type_at<0,types<T,Ts...>>{
  typedef T type;
};
template<unsigned N,class types>
using type_at_t=typename type_at<N,types>::type;
 
template<template<class>class Target,unsigned N,class types>
struct nth_apply;
template<template<class>class Target,unsigned N,class...Ts>
struct nth_apply<Target,N,types<Ts...>>{
  typedef Target<type_at_t<N,types> type;
};
template<template<class>class Target,unsigned N,class...Ts>
struct nth_apply<Target,N,types<Ts...>>{
  typedef Target<type_at_t<N,types> type;
};
template<template<class>class Target,unsigned N,class types>
using nth_apply_t=typename nth_apply<Target,N,types>::type;
 
template<class T>struct shared_maker{
  template<class...Args>
  std::shared_ptr<T> operator()(Args&&...args)const{
    return std::make_shared<T>(std::forward<Args>(args)...);
  }
  template<class R, class Args>
  operator R(*)(Args...)() const{
    return [](Args... args)->R{
      return make_shared{}(std::forward<Args>(args)...);
    };
  }
};
struct A; struct B; // etc
typedef types<A,B> Alphabet_Types;
struct Alphabet {};
template<class D>
struct Letter:Alphabet{
  static const unsigned index = index_of<D, Alphabet_Types>::value;
};
typedef std::shared_ptr<Alphabet> spAlphabet;
std::array<spAlphabet(*)(), Alphabet_Types::value> factories();
 
//the goal is simple: create the function factories that returns an array of Alphabet makers. When implementing a letter, do:
 
struct A:Letter<A>{};
 
//ie, use Letter<> as a CRTP base instead of Alphabet.
 
//The only thing left is factories.
 
template<unsigned...>struct indexes{typedef indexes type;};
template<unsigned Max, unsigned... Is> struct make_indexes:make_indexea<Max-1,Max-1,Is...>{};
template<unsigned...Is>struct make_indexes<0,Is...>:indexes<Is...>{};
 
std::array<spAlphabet(*)(), Alphabet_Types::value,unsigned...Is> factories(indexes<Is...>){
  return {nth_apply_t<shared_maker,Is,Alphabet_Types>{}...};
}
std::array<spAlphabet(*)(), Alphabet_Types::value> factories(){
  return factories(make_indexes<Alphabet_Types::value>{});
}
 
int main() {
 
}

prog.cpp:25:35: error: type/value mismatch at argument 2 in template parameter list for ‘template<unsigned int N, class types> using type_at_t = typename type_at::type’
   typedef Target<type_at_t<N,types> type;
                                   ^
prog.cpp:25:35: error:   expected a type, got ‘types’
prog.cpp:25:37: error: template argument 1 is invalid
   typedef Target<type_at_t<N,types> type;
                                     ^
prog.cpp:25:11: warning: ‘typedef’ was ignored in this declaration [enabled by default]
   typedef Target<type_at_t<N,types> type;
           ^
prog.cpp:28:8: error: redefinition of ‘struct nth_apply<Target, N, types<Ts ...> >’
 struct nth_apply<Target,N,types<Ts...>>{
        ^
prog.cpp:24:8: error: previous definition of ‘struct nth_apply<Target, N, types<Ts ...> >’
 struct nth_apply<Target,N,types<Ts...>>{
        ^
prog.cpp:40:14: error: expected identifier before ‘*’ token
   operator R(*)(Args...)() const{
              ^
prog.cpp:40:28: error: ‘<invalid operator>’ declared as function returning a function
   operator R(*)(Args...)() const{
                            ^
prog.cpp:65:72: error: expected template-name before ‘<’ token
 template<unsigned Max, unsigned... Is> struct make_indexes:make_indexea<Max-1,Max-1,Is...>{};
                                                                        ^
prog.cpp:65:72: error: expected ‘{’ before ‘<’ token
prog.cpp:65:72: error: expected unqualified-id before ‘<’ token
prog.cpp:68:59: error: expansion pattern ‘unsigned int’ contains no argument packs
 std::array<spAlphabet(*)(), Alphabet_Types::value,unsigned...Is> factories(indexes<Is...>){
                                                           ^
prog.cpp:68:64: error: wrong number of template arguments (3, should be 2)
 std::array<spAlphabet(*)(), Alphabet_Types::value,unsigned...Is> factories(indexes<Is...>){
                                                                ^
In file included from /usr/include/c++/4.8/tuple:39:0,
                 from /usr/include/c++/4.8/functional:55,
                 from /usr/include/c++/4.8/memory:79,
                 from prog.cpp:1:
/usr/include/c++/4.8/array:81:12: error: provided for ‘template<class _Tp, unsigned int _Nm> struct std::array’
     struct array
            ^
prog.cpp:68:84: error: ‘Is’ was not declared in this scope
 std::array<spAlphabet(*)(), Alphabet_Types::value,unsigned...Is> factories(indexes<Is...>){
                                                                                    ^
prog.cpp:68:86: error: expected parameter pack before ‘...’
 std::array<spAlphabet(*)(), Alphabet_Types::value,unsigned...Is> factories(indexes<Is...>){
                                                                                      ^
prog.cpp:68:89: error: template argument 1 is invalid
 std::array<spAlphabet(*)(), Alphabet_Types::value,unsigned...Is> factories(indexes<Is...>){
                                                                                         ^
prog.cpp: In function ‘int factories(int)’:
prog.cpp:69:36: error: ‘Is’ was not declared in this scope
   return {nth_apply_t<shared_maker,Is,Alphabet_Types>{}...};
                                    ^
prog.cpp:69:53: error: template argument 2 is invalid
   return {nth_apply_t<shared_maker,Is,Alphabet_Types>{}...};
                                                     ^
prog.cpp:69:59: error: cannot convert ‘<brace-enclosed initializer list>’ to ‘int’ in return
   return {nth_apply_t<shared_maker,Is,Alphabet_Types>{}...};
                                                           ^
prog.cpp: In function ‘std::array<std::shared_ptr<Alphabet> (*)(), 2u> factories()’:
prog.cpp:72:56: error: invalid use of incomplete type ‘struct make_indexes<2u>’
   return factories(make_indexes<Alphabet_Types::value>{});
                                                        ^
prog.cpp:65:47: error: declaration of ‘struct make_indexes<2u>’
 template<unsigned Max, unsigned... Is> struct make_indexes:make_indexea<Max-1,Max-1,Is...>{};
                                               ^
prog.cpp: In function ‘int factories(int)’:
prog.cpp:70:1: warning: control reaches end of non-void function [-Wreturn-type]
 }
 ^
prog.cpp: In function ‘std::array<std::shared_ptr<Alphabet> (*)(), 2u> factories()’:
prog.cpp:73:1: warning: control reaches end of non-void function [-Wreturn-type]
 }
 ^

Standard output is empty