C-Style Cast

The (type) operator, formally defined as the C-style cast expression, is a unary operator used for explicit type conversion. In C++, it instructs the compiler to convert the value of an expression to a specified target type by systematically mapping to one or more underlying C++ named cast operations.

(target_type) expression

Mechanical Behavior

Unlike C++ named casts, the (type) operator does not represent a single conversion algorithm. When the C++ compiler evaluates a C-style cast, it attempts to interpret the conversion by sequentially evaluating specific categories of C++ cast operations. The compiler selects the first interpretation from the sequence that matches the conversion category, even if that specific cast is ill-formed. If the matched interpretation is ill-formed (e.g., casting to an ambiguous base class), the compilation fails; the compiler does not fall back to the next operation in the sequence.

The sequence of interpretations is:

1. const_cast<target_type>(expression): Modifies const or volatile qualifiers without changing the underlying type.
2. static_cast<target_type>(expression): Performs standard implicit conversions, user-defined conversions, or unchecked downcasts/upcasts within a class hierarchy.
3. static_cast followed by const_cast: Combines a standard conversion or unchecked cast with a change in cv-qualifiers.
4. reinterpret_cast<target_type>(expression): Performs a low-level, bitwise reinterpretation of the memory layout (e.g., converting between unrelated pointer types).
5. reinterpret_cast followed by const_cast: Combines a bitwise reinterpretation with a change in cv-qualifiers.

The transition from static_cast to reinterpret_cast (step 3 to 4) occurs only if the types involved cannot be structurally interpreted as a static_cast (such as casting between unrelated pointer types). It does not fall back simply because a matched static_cast violates a constraint and fails to compile.

Technical Characteristics

• Precedence and Associativity: The (type) operator has right-to-left associativity and sits at precedence level 3, sharing the same precedence as other unary operators like logical NOT (!), address-of (&), and dereference (*).
• Access Control Bypass: A unique structural property of the C-style cast in C++ is its ability to ignore class access specifiers during inheritance conversions. While a static_cast will fail to compile if attempting to cast a derived class pointer to a private or protected base class pointer, the (type) operator will successfully perform the cast by ignoring the access boundaries.
• Type Safety: Because the operator can silently resolve to a reinterpret_cast when types do not meet static_cast criteria, it bypasses the strict type-checking mechanisms of the C++ type system, offering no compile-time guarantees regarding the validity of the resulting memory interpretation.
• Value Category: The value category of the cast expression depends on the target type:
  • Casting to an lvalue reference type ((T&)expr) results in an lvalue.
  • Casting to an rvalue reference to an object type ((T&&)expr) results in an xvalue.
  • Casting to an rvalue reference to a function type results in an lvalue.
  • Casting to a non-reference type ((T)expr) results in a prvalue (pure rvalue).

Master C++ with Deep Grasping Methodology!

Learn More