> ## 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. # C++ Const Cast `const_cast` is a C++ type conversion operator explicitly designed to add or remove the `const` (constness) or `volatile` (volatility) qualifiers from a pointer, reference, or pointer-to-member type. It is the only C++ style cast capable of manipulating cv-qualifiers. ## Syntax ```cpp theme={"dark"} const_cast(expression) ``` * **`new_type`**: Must be a pointer, reference, or pointer-to-member type. * **`expression`**: The value being cast. Its underlying base type must exactly match the base type of `new_type`. ## Technical Mechanics and Rules **1. Strict Type Matching** `const_cast` cannot change the underlying data type of the object. It only alters the cv-qualifiers. Attempting to cast between different base types (e.g., from `const int*` to `char*`) will result in a compiler error. ```cpp theme={"dark"} const int* ptr = nullptr; int* modifiable_ptr = const_cast(ptr); // Valid: Base type is 'int' // char* char_ptr = const_cast(ptr); // Error: Cannot change base type ``` **2. Pointer and Reference Restriction** The operator operates exclusively on pointers, references, and pointers-to-members. It cannot be used to cast objects by value. ```cpp theme={"dark"} const int val = 10; // int new_val = const_cast(val); // Error: new_type must be a pointer or reference const int& ref = val; int& modifiable_ref = const_cast(ref); // Valid: Operates on a reference ``` **3. Adding vs. Removing Qualifiers** While most commonly associated with casting *away* constness, `const_cast` is bidirectional. It can safely add `const` or `volatile` qualifiers to a non-qualified type, though an implicit conversion is usually sufficient for adding `const`. ```cpp theme={"dark"} int x = 5; int* p = &x; const int* cp = const_cast(p); // Valid: Adding constness ``` ## Undefined Behavior (UB) The most critical technical distinction regarding `const_cast` is the difference between the legality of the *cast* and the legality of the *memory access*. Using `const_cast` to strip the `const` qualifier from a pointer or reference is always valid C++. However, **modifying** the underlying object through the resulting pointer/reference invokes Undefined Behavior if the original object was declared as `const`. **Well-Defined Behavior (Original object is non-const):** ```cpp theme={"dark"} int original_non_const = 42; const int* ptr_to_const = &original_non_const; // Cast away constness int* modifiable_ptr = const_cast(ptr_to_const); // Valid: The original object in memory is not const. *modifiable_ptr = 100; ``` **Undefined Behavior (Original object is const):** ```cpp theme={"dark"} const int original_const = 42; const int* ptr_to_const = &original_const; // Cast away constness (The cast itself is legal) int* modifiable_ptr = const_cast(ptr_to_const); // UNDEFINED BEHAVIOR: Attempting to write to memory declared as const. // The compiler may have placed 'original_const' in read-only memory (ROM). *modifiable_ptr = 100; ``` ## Compile-Time Evaluation `const_cast` is a compile-time directive. It does not generate any executable machine code and incurs zero runtime overhead. It merely instructs the compiler's type-checking system to treat the referenced memory address with a different set of cv-qualifiers for the duration of the expression.

Tired of Poor C++ Skills? Fix That With Deep Grasping! Learn More