C++ Functional Cast

​

decltype(...)

decltype(entity)
decltype(expression)

1. Unparenthesized id-expression or class member access: If the operand is an unparenthesized identifier or a member access expression (obj.member or ptr->member), decltype yields the exact declared type of the entity.
2. Parenthesized expression or other expressions: If the operand is an expression of type T, the resulting type depends on the expression’s value category:
   • If the expression is an lvalue, decltype yields T&.
   • If the expression is an xvalue, decltype yields T&&.
   • If the expression is a prvalue, decltype yields T.

#include <utility>

int x = 0;
const int cx = 0;
int& rx = x;
struct S { int m; };
S s;

using T1 = decltype(x);            // Yields: int
using T2 = decltype(cx);           // Yields: const int
using T3 = decltype(rx);           // Yields: int&
using T4 = decltype(s.m);          // Yields: int (unparenthesized member access)
using T5 = decltype((s.m));        // Yields: int& (parenthesized lvalue expression)
using T6 = decltype(x + 1);        // Yields: int (prvalue expression)
using T7 = decltype(std::move(x)); // Yields: int&& (xvalue expression)

​

typeid(...)

typeid(type)
typeid(expression)

1. Type Operand: If the operand is a type-id, typeid evaluates at compile-time and yields the const std::type_info for that exact type.
2. Non-Polymorphic Expression Operand: If the operand is an expression whose static type is not a polymorphic class (a class with at least one virtual function), typeid evaluates at compile-time. The expression is not executed.
3. Polymorphic Expression Operand: If the operand is a glvalue expression of a polymorphic class type, typeid evaluates at run-time. It inspects the vtable to yield the const std::type_info of the most derived (dynamic) type of the object.
4. Null Pointer Dereference: If the operand is a dereferenced null pointer of a polymorphic class type (e.g., typeid(*ptr) where ptr evaluates to a null pointer value), the operator throws a std::bad_typeid exception.
5. CV-Qualifiers and References: typeid strips top-level const and volatile qualifiers and ignores references before evaluation. typeid(T&) and typeid(const T) both yield the const std::type_info for T.

#include <typeinfo>

struct Base { virtual ~Base() = default; };
struct Derived : Base {};
struct NonPolyBase {};
struct NonPolyDerived : NonPolyBase {};

int x = 5;
const int& rx = x;

// Compile-time evaluation
const std::type_info& t1 = typeid(int);
const std::type_info& t2 = typeid(rx);        // Yields type_info for 'int' (cv-ref stripped)
const std::type_info& t3 = typeid(x + 1.5);   // Yields type_info for 'double'

// Compile-time vs Run-time evaluation
Derived d;
Base& b_ref = d;
NonPolyDerived npd;
NonPolyBase& npb_ref = npd;

const std::type_info& t4 = typeid(b_ref);     // Run-time: Yields type_info for 'Derived' (polymorphic)
const std::type_info& t5 = typeid(npb_ref);   // Compile-time: Yields type_info for 'NonPolyBase' (static type)

// Null pointer dereference
Base* null_ptr = nullptr;
// const std::type_info& t6 = typeid(*null_ptr); // Throws std::bad_typeid at run-time