> ## 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++ Bitwise NOT The `~` operator in C++ is the unary bitwise NOT operator, also known as the one's complement operator. It evaluates its operand and returns a value where every bit of the operand's binary representation has been inverted: every `0` becomes a `1`, and every `1` becomes a `0`. ## Syntax ```cpp theme={"dark"} ~expression ``` ## Operand and Type Requirements The operand must be of an integral type or an unscoped enumeration type. Before the bitwise inversion occurs, C++ applies **integral promotions** to the operand: * Types smaller than `int` (e.g., `char`, `signed char`, `unsigned char`, `short`, `unsigned short`) are promoted to `int` (or `unsigned int` if `int` cannot represent all values of the original type). * The bitwise inversion is performed on the promoted type. * The result is a prvalue (pure rvalue) of the promoted type. ## Bitwise Mechanics and Integral Promotion Because of integral promotion, applying `~` to smaller integer types alters the bit width of the evaluated expression. ```cpp theme={"dark"} #include #include uint8_t val = 0b00001111; // Decimal 15 // 'val' is promoted to a 32-bit int before inversion: // 00000000 00000000 00000000 00001111 // After ~ operation: // 11111111 11111111 11111111 11110000 auto result = ~val; static_assert(std::is_same_v); // True ``` ## Mathematical Equivalence In C++20 and later, signed integers are strictly defined to use two's complement representation. Under two's complement arithmetic, the bitwise NOT operation is mathematically equivalent to negating the value and subtracting one: ```cpp theme={"dark"} int x = 5; int y = ~x; // y is -6 // ~x == -x - 1 ``` ## Operator Overloading The `~` operator can be overloaded for user-defined types. When overloaded as a non-member function, it takes exactly one parameter. When overloaded as a member function, it takes no parameters. ```cpp theme={"dark"} struct CustomType { int value; // Member function overload CustomType operator~() const { return CustomType{~value}; } }; ``` ## Destructor Token Distinct from its role as an expression operator, the `~` token is also used syntactically in class definitions to declare a destructor. In this context, it acts as a declarative identifier prepended to the class name and does not perform a bitwise operation. ```cpp theme={"dark"} class Resource { public: Resource(); // Constructor ~Resource(); // Destructor }; ```

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