Comma operator with typeid

Question

I was studying A Generic Non-intrusive Smart Pointer Implementation. I have some confusion in section 4. One statement is

the expression supplied as the argument to the typeid operator is only evaluated if the result type is an lvalue of polymorphic class type.

And associated example code is:

template<typename T>
  void* startOfObject(T* p) {
  void* q=static_cast<void*>(p);
  typeid(q=dynamic_cast<void*>(p),*p); // This line
  return q;
}

AFAIU, it means q=dynamic_cast<void*>(p) will be evaluated if the result type is an lvalue of polymorphic class type. The result means the result of evaluating dynamic_cast<void*>(p) (I guess), so the dynamic_cast has to be applied in any case. The articles states (as I understand) that if p is not polymorphic then dynamic_cast will not be applied, but why? Before applying it, how can it be known whether the result is polymorphic or not? It will be helpful if someone describes in details how the full statement will be executed.

Another statement is

There is also a problem if p is NULL – the typeid will throw a std::bad cast.

The problem I see is with de-referencing if p is NULL, not with typeid (although it may throw bad_typeid, but that is not because of casting). dynamic_cast will return a NULL pointer of type void* if p is NULL, and typeid should be able to deduce the type information. Is that a typo, or am I missing something?

Answer 1

It's a fancy trick to write essentially the following code

if (T is polymorphic)
  return dynamic_cast<void*>(p);
else
  return static_cast<void*>(p);

The trick used is that typeid(expr) is evaluated in one of two ways. If the compiler determines that expr has a non-polymorphic type, it goes ahead and uses its static type. But if expr has a dynamic type, it evaluates expr at runtime. The assignment before the comma operator is therefore evaluatad if and only if *p after the comma is polymorphic.

The null case is complex for that reason. If T is not polymorphic, then typeid(*p) is replaced by the compiler at compile time, and the runtime null pointer doesn't matter at all. If T is polymorphic, special handling of null pointer dereferences applies, and that special handling states that a std::bad_typeid exception is thrown.

Answer 2

The comma operator has left-to-right associativity and is evaluated from left to right. That means the result of the expression q=dynamic_cast<void*>(p),*p is *p. So the dynamic cast is only evaluated if the type of *p is polymorphic.

Regarding the NULL problem the standard states:

When typeid is applied to an lvalue expression whose type is a polymorphic class type (10.3), the result refers to a type_info object representing the type of the most derived object (1.8) (that is, the dynamic type) to which the lvalue refers. If the lvalue expression is obtained by applying the unary * operator to a pointer and the pointer is a null pointer value (4.10), the typeid expression throws the bad_typeid exception (18.5.3).

Answer 3

Explanation

Since C++ is a statically typed language the type of every expression is known at compile-time, even in cases that involves polymorphic behavior.

Whether a certain class is polymorphic or not is known at the time of compilation, this property will and cannot be changed between program executions.

If the compiler sees that the expr in typeid(expr) will not yield a value of polymorphic class type, it will simply make expr "unevaluated", which is equivalent of not executing it during run-time.

---

! ! !

It is important to note that the expr must still be valid, we cannot use typeid to potentially ignore a ill-formed expression; a compiler diagnostic must still be issued if the expression is ill-formed.

Just because the expr will be "unevaluated" does not mean that we can have it contain an ill-formed sub-expression.

struct A { }; // not polymorphic

...

A * ptr = ...;
typeid (dynamic_cast<void*> (ptr), *ptr); // ill-formed

Since ptr is not a pointer to a polymorphic class we cannot use it in dynamic_cast<T> where T = void*, as specified in [expr.dynamic.cast]p6.

---

Dereferencing a potential nullptr?

This will make typeid throw an exception, so it will not yield undefined behavior but one should be prepared to handle an exception if one uses such implementation.

5.2.8p2 Type identification [expr.typeid]

(...) If the glvalue expression is obtained by applying the unary * operator to a pointer and the pointer is a null pointer value (4.10), the typeid expression throws an exception (15.1) of a type that would match a handler of type std::bad_typeid exception (18.8.3)

---

Clarification

It means q=dynamic_cast(p) will be evaluated if the result type is an lvalue of polymorphic class type. The result means the result of evaluating dynamic_cast(p) (I guess).

No, what the author is saying is that if the resulting type of the entire expression is a polymorphic class type, than the expression will be evaluated.

_{Note: The "entire expression" refers to the ... in typeid(...), in your case; q=dynamic_cast<void*>(p),*p.}

---

The Comma Operator

The comma operator will take two operands expr1 and expr2, it will start off by evaluating expr1 and then discard this value, after which it will evaluate expr2 and yield the value of this expression.

• How does the comma operator work?

---

Putting it together

This means that the resulting type of using a comma operator is as if it only consisted of the right-hand-side expression, and in the following line the compiler will check so that the result of expr2 is a type which is a polymorphic class.

typeid (expr1, expr2)

typeid (q=dynamic_cast<void*>(p), *p)

// expr1 = q=dynamic_cast<void*>(p)
// expr2 = *p

---

^{Note: In C++03 the resulting type had to be a polymorphic lvalue, in C++11 this has been changed to glvalues of polymorphic class type.}

Answer 4

The result means the result of evaluating dynamic_cast(p) (I guess), so the dynamic_cast has to be applied in any case. The articles states (as I understand) that if p is not polymorphic then dynamic_cast will not be applied

dynamic_cast will not be applied if any of the involved types have no polymorphic relationship with each other, with the exception of being able to cast to void*.

Now for the whole construct, if you run it through a compiler that has good warnings, you will either see

error: cannot dynamic_cast 'p' (of type 'struct A*') to type 'void*' (source type is not polymorphic)

or when A is polymorphic, you will see

warning: value computed is not used [-Wunused-value]

for

typeid(q=dynamic_cast<void*>(p),*p); // this line

So in my opinion, the whole line makes no sense at all, other than to possibly prevent compilation when the source type is not polymorphic.

As to the built in comma operator that is being used here: It is being evaluated from left to right, always unconditionally, and its result is the last element. That is, the result is equivalent to

typeid(*p);

which is not being used and thus a pretty useless construct. Would it compile for non polymorphic source types in the dynamic_cast, then it would not be evaluated at runtime at all since the type of *p is known at compile time.

ISO14882:2001(e) §5.18-1

A pair of expressions separated by a comma is evaluated left-to-right; the left expression is a discarded-value expression (Clause 5).⁸³ Every value computation and side effect associated with the left expression is sequenced before every value computation and side effect associated with the right expression. The type and value of the result are the type and value of the right operand; the result is of the same value category as its right operand, and is a bit-field if its right operand is a glvalue and a bit-field.

Regarding the nullptr issue

There is also a problem if p is NULL – the typeid will throw a std::bad cast.

There is a special case in the standard to make this not undefined behaviour:

If the glvalue expression is obtained by applying the unary * operator to a pointer⁶⁸ and the pointer is a null pointer value (4.10), the typeid expression throws the std::bad_typeid exception (18.7.3).