Using typeid to check for template type

Question

I would like to know if doing the following is safe:

template<class T>
void Parameters::add(Parameter<T> p)
{
   std::string sprobe("");
   int iprobe = 0;
   double dprobe = 0.;

   if (typeid(T) == typeid(sprobe))
     this->mstrings[p.name()] = p;

   if (typeid(T) == typeid(iprobe))
     this->mints[p.name()] = p;

   if (typeid(T) == typeid(dprobe))
     this->mdoubles[p.name()] = p;
}

I have a Class for storing parameters. It has 3 boost::unordered_map member variables for storing parameters of type int, double and std::string;

I created a template class Parameter.

I understand that if my Parameter is not one of the 3 types that I anticipated this will fail. But it is not a problem since I know that the Parameters can only be of these types.

Thanks for your help

It sounds like you want template specialization. Or even just overloading. — Sneftel, Sep 16 '14 at 15:58
I think that overloading would do the trick. Thanks a lot But is it safe to use typeid in this context ? — tvery42, Sep 16 '14 at 16:03
`typeid` is RTTI, it may not be enabled at all, also, it drops *cv* qualifiers — Piotr Skotnicki, Sep 16 '14 at 16:05
BTW, your solution can be improved a little bit with this: 1) You don't need to set int iprobe = 0 to get a type_info of int. Just do typeid( int ); 2) You can have only one unordered_map, and the value type make it a boost::any or std::any. That way you only will need one map to store them all. — Pato Sandaña, Dec 03 '18 at 13:19

score 5 · Answer 1 · answered Sep 16 '14 at 16:25

The code won't compile, but not because of typeid. The problem is that even with the correct if-clauses, the code of your method needs to be compiled - all of it. That is independent of whether or not a part of the code is executed (=evaluated) or not. This leads to the problem that if T is int, you still need to be able to compile the code for the other cases, e.g., this line:

this->mstrings[p.name()] = p;

The type of mstrings is very likely incompatible with passing Parameter<int> as p, hence you will get a compile error.

The solution is to use overloading where each method must only compile one case, but not the others, example for int:

void Parameters::add(Parameter<int> p)
{
    this->mints[p.name()] = p;
}

and likewise for the other cases.

Final note: Even if you use typeid, you don't need the probes. You can simply use typeid(int) directly.

score 0 · Answer 2 · edited Jun 20 '20 at 09:12

Ignoring whether that is a good programming practice or not ...

Your program is safe from the language point of view. Comparison of type_info, the valued returned by the typeid operator, is well defined in the standard:

18.5.1 Class type_info

...

bool operator==(const type_info& rhs) const;

2 Effects: Compares the current object with rhs.

3 Returns: true if the two values describe the same type.

Using typeid to check for template type

2 Answers2

Linked