Is it possible to create a variational tuple from a string?

constexpr std::tuple<int,char,int,char> t1 = parse("1a2b");
constexpr std::tuple<int,int,int,char> t2 = parse("123a");
constexpr std::tuple<char,int> t3 = parse("a2");


Is this possible?

I'm not quite fluent with TMP, but I started with the following

template<std::size_t N,typename ...Args> constexpr
std::tuple<Args...> parse(const char* s[N]){
  constexpr char c = s[0];
  constexpr char* new_s[N-1] = "";
  for (int i = 1; i < N; i++) {
    new_s[i] = s[i];
  //my own constexpr isdigit
    return parse(new_s,c);
  else if(isdigit(c)){
    return parse(new_s,static_cast<int>(c));
  throw std::invalid_argument("");


I wanted to do this recursively and accumulate the tuple, but I quickly realized that every time I pass a new tuple the type will change.


source to share

1 answer

Since it parse

must return different types for "1a2b"

and "123a"

, it is obvious that characters containing a string literal must be part of the template parameters. It's pretty easy to do something like

constexpr bool my_isdigit(char c){
    return c >= '0' && c <= '9';
template<char c, bool = my_isdigit(c)>
struct mapper {
    using type = char;
    static constexpr char value = c;

template<char c>
struct mapper<c, true> {
    using type = int;
    static constexpr int value = c - '0';

template<char... chars> 
constexpr auto parse(){
    return std::tuple<typename mapper<chars>::type...>(mapper<chars>::value...);

constexpr auto p = parse<'1', 'a', '2', 'b'>();


If you really want to use string literals, there are tricks that allow you to explode a string literal into an options package .



All Articles