Skip to main content

Documentation Index

Fetch the complete documentation index at: https://docs.syntblaze.com/llms.txt

Use this file to discover all available pages before exploring further.

The (type) operator, formally known as the explicit type cast operator, is a unary operator that instructs the compiler to convert the evaluated result of an expression into a specified scalar data type or void. 
(type_name) expression

​
Mechanics and Evaluation

  • Rvalue Generation: The cast operator yields a new value (an rvalue) of the specified type_name. It does not modify the type or the stored value of the original operand in memory.
  • Precedence and Associativity: It is a Level 2 operator in C precedence (alongside other unary operators like &, *, sizeof), evaluating right-to-left. Because of its high precedence, the cast applies to the immediate adjacent operand. Casting the result of an entire operation requires enclosing the expression in parentheses: (type_name)(expression).
  • Compile-Time Resolution: The conversion logic is determined at compile time. Depending on the source and target types, the compiler emits instructions to perform bitwise truncation, sign/zero extension, floating-point conversion, or pointer type adjustment.

​
Type Constraints

The C Standard imposes strict rules on what types are eligible for casting:
  1. Scalar to Scalar: If the target type_name is a scalar type (arithmetic or pointer), the original expression must also evaluate to a scalar type.
  2. Non-Scalar Types: You cannot cast to an aggregate type (arrays or structs) or a union type. You also cannot cast from an aggregate or union type, with the sole exception of casting to void.
  3. Void: Any expression can be cast to void. This explicitly indicates to the compiler that the evaluated result of the expression is intentionally discarded.

​
Type Qualifiers

The cast operator interacts directly with type qualifiers (const, volatile, restrict). A primary mechanic of explicit pointer casting is adding or removing these qualifiers from a type. While casting away a qualifier (e.g., converting const int * to int *) is syntactically valid and yields an unqualified pointer, attempting to modify an originally const-qualified object through that new pointer results in undefined behavior.

​
Conversion Behaviors

When the (type) operator is applied, the underlying bit-level transformation depends on the type categories involved:
  • Integer to Integer:
    • Downcasting (Larger to Smaller): If the target type is unsigned, the value is truncated by discarding the higher-order bits. If the target type is signed and the value cannot be represented in the new type, the result is implementation-defined or an implementation-defined signal is raised.
    • Upcasting (Smaller to Larger): The value is extended. Unsigned types undergo zero-extension; signed types undergo sign-extension.
  • Floating-Point to Integer: The fractional portion is truncated (rounded towards zero). If the integral part cannot be represented by the target integer type, the behavior is undefined.
  • Integer to Floating-Point: If the integer value cannot be represented exactly in the target floating-point type, the result is either the nearest higher or nearest lower representable value. The exact choice is implementation-defined or dictated by the active floating-point rounding mode.
  • Pointer to Pointer: The cast operator changes the type of the pointer expression itself. The conversion is undefined behavior if the resulting pointer is not correctly aligned for the referenced type. If alignment requirements are met, the memory address remains unchanged, but subsequent dereferencing of the new pointer is subject to strict aliasing rules.
  • Pointer to Integer / Integer to Pointer: The conversion is implementation-defined. The integer type must be sufficiently large (e.g., uintptr_t) to hold the pointer value without truncation, otherwise undefined behavior occurs.

​
Syntax Visualization

#include <stdio.h>

struct Record {
    int id;
};

int process_data(void) {
    return 1;
}

int main(void) {
    int a = 5;
    int b = 2;
    int val = 10;
    int *pointer_to_int = &val;
    const int read_only_val = 42;
    struct Record rec = {0};

    /* Basic scalar cast */
    unsigned int u_val = (unsigned int) -1;

    /* Integer downcasting: guaranteed truncation for unsigned target */
    unsigned char u_char_val = (unsigned char) 257; /* Results in 1 */

    /* Integer downcasting: implementation-defined for signed target if unrepresentable */
    signed char s_char_val = (signed char) 257; 

    /* Casting a pointer type (requires compatible alignment) */
    char *pointer_to_char = (char *) pointer_to_int;

    /* Casting away a type qualifier (const) */
    int *mutable_ptr = (int *) &read_only_val;

    /* Casting a struct (non-scalar) to void */
    (void) rec;

    /* Casting to void to explicitly discard a return value */
    (void) process_data();

    /* Precedence: casts 'a' to float first, resulting in floating-point division (2.5) */
    float float_div = (float) a / b; 

    /* Precedence: performs integer division first (2), then casts the result to float (2.0) */
    float int_div_casted = (float) (a / b);

    return 0;
}
Master C with Deep Grasping Methodology!Learn More