Enum variable as a dynamic template argument

Question

Let's assume, that we have an enumered type:

enum DataType { INT, DOUBLE };

And a type mapper:

template<DataType T>
struct TypeTraits {}; 

template<>
struct TypeTraits<INT> { typedef int T; };

template<>
struct TypeTraits<DOUBLE> { typedef double T; };

And a few templates which represents operations (don't bother about ugly void pointers, and C-like typecasts):

struct Operation {
  DataType rettype;

  Operation(DataType rettype) : rettype(rettype);
  virtual void* compute();
};

template<DataType RetType>
class Constant : public Operation {
  typedef typename TypeTraits<RetType>::T RType;
  RType val;

  Constant(RType val) : val(val), Operation(RetType) {}; 
  virtual void* compute(){ return &val; }
};  

template<DataType T1, DataType T2, DataType RetType>
class Add : public Operation {
  typedef typename TypeTraits<RetType>::T1 T1Type;
  typedef typename TypeTraits<RetType>::T2 T2Type;
  typedef typename TypeTraits<RetType>::RetType RType;
  RType val;

  Operation *c1, *c2;

  Add(Operation *c1, Operation *c2) : c1(c1), c2(c2), Operation(RetType) {}; 

  virtual void* compute(){
    T1Type *a = (T1Type *)c1->compute();
    T2Type *b = (T2Type *)c2->compute();
    val = *a + *b; 
    return &val;
  }   
};

And a abstract tree representation:

class AbstractNode {
  enum Type { ADD, INT_CONSTANT, DOUBLE_CONSTANT };

  Type type;
  int intval;
  double doubleval;
  child1 *AbstractNode;
  child2 *AbstractNode;
}

We're reading a serialized abstract tree from input in order to translate it into an operation tree, and then - compute a result.

We want to write something like:

algebrator(Operation *op){
  if(op->type == AbstractNode::INT_CONSTANT)
    return new Constant<INT>(op->intval);
  else if(op->type == AbstractNode::DOUBLE_CONSTANT)
    return new Constant<DOUBLE>(op->doubleval);
  else {
    Operation *c1 = algebrator(op->child1),
              *c2 = algebrator(op->child2);
    DataType rettype = add_types_resolver(c1->rettype, c2->rettype);
    return new Add<c1->rettype, c2->rettype, rettype>(c1, c2);
  }
}

where add_types_resolver is something which specifies the return type of add operation based on operation arguments types.

And we fail of course and compiler will hit us into the faces. We can't use a variable as a template variable! It's because all information needed to instantiate template must be available during the compliation!

And now - the question.

Is there any other solution than writing a plenty of if-else, or switch-case statements? Can't we ask a compiler in any way to expand all cases during compilation? Template is parametrized by the enum, so we have a guarantee, that such process is finite.

And please - don't write responses like "I think the whole example is messed up". I just want to know if there's a way to feed the template with variable, knowing it's from a finite, small set.

The whole thing may seem like an overkill, but I'm really curious how can I instantiate classes in such unusual situations.

The whole example is messed up. Templates are parametrised on types and compile-time constants, not on runtime values. But it sounds like you were already aware of that... — Oliver Charlesworth
– Oliver Charlesworth, Commented Apr 2, 2012 at 22:07
You can use the int-to-type idiom to generate compile time types for templates based off values however whether that's a good idea or not is entirely another matter. — AJG85
– AJG85, Commented Apr 2, 2012 at 22:14
It shouldn't be very hard to factor out the dynamic lookup code into one corner of your program and make it usable without too much noise. — Kerrek SB
– Kerrek SB, Commented Apr 2, 2012 at 22:14
You can use things like boost::mpl to have the compiler generate all if/switch cases for you. It's not straight forward though. — J.N.
– J.N., Commented Apr 2, 2012 at 22:16

Michał Oniszczuk · Accepted Answer · 2012-04-28 11:35:35Z

Quick'n'dirty solution with macros:

column_type.cc:

enum ColumnType {
  INT = 1,
  DOUBLE = 2,
  BOOL = 3
};

typed_call_test.cc (usage example):

#include <iostream>
#include "column_type.cc"
#include "typed_call.cc"

template <ColumnType T>
void PrintType() {
  ::std::cout << T <<::std::endl;
}

int main() {
  ColumnType type = INT;
  // this won't compile:
  // PrintType<type>();                  
  // and instead of writing this:
  switch (type) {                  
    case INT:                  
      PrintType<INT>();                  
      break;                  
    case DOUBLE:                  
      PrintType<DOUBLE>();                  
      break;                  
    case BOOL:                  
      PrintType<BOOL>();                  
      break;                  
  }                  
  // now you can write this:
  TYPED_CALL(PrintType, type, );

  return 0;
}

typed_call.cc ("library"):

// Requirements:
// |function| return type must be void
//
// Usage:
//
// having for instance such |type| variable:
//   ColumnType type = INT;
// and such |foo| function definition:
//   template <ColumnType T>
//   void foo(t1 arg1, t2 arg2) {
//     …
//   }
//
// instead of writing (won't compile):
//   foo<type>(arg1, arg2);                  
// write this:
//   TYPED_CALL(foo, type, arg1, arg2);
//
//
// for foo with 0 arguments write this:
//   TYPED_CALL(foo, type, );
//
#define TYPED_CALL(function, type, args...) {                        \
  switch (type) {                                                    \
    case INT:                                                        \
      function<INT>(args);                                           \
      break;                                                         \
    case DOUBLE:                                                     \
      function<DOUBLE>(args);                                        \
      break;                                                         \
    case BOOL:                                                       \
      function<BOOL>(args);                                          \
      break;                                                         \
  }                                                                  \
}

#define BASE_TYPED_CALL(function, type, args...) {                   \
  switch (type) {                                                    \
    case INT:                                                        \
      function<int>(args);                                           \
      break;                                                         \
    case DOUBLE:                                                     \
      function<double>(args);                                        \
      break;                                                         \
    case BOOL:                                                       \
      function<bool>(args);                                          \
      break;                                                         \
  }                                                                  \
}

To take this solution "level up" you can replace macro with a function (still containing similiar switch construct). But probably you would like to pass a functor (object with () operator) as a parameter of this function instead of an ordinary function like in this macro. Btw: this is exactly how they do it in Google.

1st sidenote: hi to my classmate from the Columnar and Distributed DataWarehouses course on University of Warsaw! This course is generating a lot of mind-bending C++ template questions :)

2nd sidenote: here is how my equivalent of Typetraits looks like:

template <ColumnType T>
struct EnumToBuiltin {
};

template <>
struct EnumToBuiltin<INT> {
  typedef int type;
};
template <>
struct EnumToBuiltin<DOUBLE> {
  typedef double type;
};
template <>
struct EnumToBuiltin<BOOL> {
  typedef bool type;
};


template <typename T>
struct BuiltinToEnum {
};

template <>
struct BuiltinToEnum<int> {
  static const ColumnType type = INT;
};
template <>
struct BuiltinToEnum<double> {
  static const ColumnType type = DOUBLE;
};
template <>
struct BuiltinToEnum<bool> {
  static const ColumnType type = BOOL;
};

justin · Accepted Answer · 2012-04-02 22:15:17Z

0

Can't we ask a compiler in any way to expand all cases during compilation?

You can do this. Introduce the condition->TMP where it is dynamic. If you do it in the right places, then you will have few conditionals to write. Introducing types and constants as compile time information will help minimize this.

answered Apr 2, 2012 at 22:15

justin

105k14 gold badges185 silver badges227 bronze badges

Collectives™ on Stack Overflow

Enum variable as a dynamic template argument

2 Answers 2

Comments

Comments

Your Answer

Hot Network Questions

Collectives™ on Stack Overflow

2 Answers 2

Comments

Comments

Your Answer

Sign up or log in

Post as a guest

Related