> ## 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 Complement The `~` (bitwise NOT) operator is a unary operator in C that performs a bitwise negation (or one's complement) on each individual bit of its integer operand. It evaluates the binary representation of the value, converting every `0` bit to `1` and every `1` bit to `0`. ## Syntax ```c theme={"dark"} ~operand ``` The `operand` must be of an integral type (e.g., `char`, `short`, `int`, `long`, or their `unsigned` variants). ## Bit-Level Mechanics When the operator is applied, the evaluation occurs strictly at the binary level. ```text theme={"dark"} Operand: 0 1 0 1 1 0 1 0 (Binary) | | | | | | | | Result: 1 0 1 0 0 1 0 1 (Binary) ``` ## Integer Promotion A critical characteristic of the `~` operator in C is that it applies **integer promotions** to its operand before performing the bitwise inversion. The type of the result is the type of the promoted operand. If you apply `~` to a type smaller than an `int` (such as `uint8_t`, `int8_t`, `char`, or `short`), the compiler first widens the value to a standard `int` (typically 32 bits) or `unsigned int`. During this promotion, the padding of the new high-order bits depends on the signedness and value of the original type: * **Unsigned types** and **non-negative signed values** are zero-extended (padded with zeros). * **Negative signed values** undergo sign-extension (padded with ones). The bitwise inversion then flips all bits of the newly promoted width. ```c theme={"dark"} #include uint8_t a = 0x0F; // Binary: 0000 1111 // Promoted to 32-bit int (zero-extended): // 00000000 00000000 00000000 00001111 int result = ~a; // Binary: 11111111 11111111 11111111 11110000 // Hex: 0xFFFFFFF0 // Type: int (not uint8_t) ``` To retain the original bit-width, the result must be explicitly cast back to the smaller type: ```c theme={"dark"} uint8_t b = (uint8_t)~a; // Binary: 1111 0000 (0xF0) ``` ## Two's Complement Equivalence and Overflow Because modern C implementations utilize two's complement representation for signed integers, the bitwise NOT operation has a direct mathematical relationship with arithmetic negation. Mathematically, the one's complement of an integer `x` is equivalent to its arithmetic negation minus one: ```text theme={"dark"} ~x == -x - 1 ``` For example, if `x = 5` (binary `0000 0101`), `~x` results in `-6` (binary `1111 1010` in an 8-bit two's complement system). **Important Caveat Regarding Undefined Behavior:** While the mathematical equivalence holds true, expressing this relationship directly as arithmetic C code (e.g., `-x - 1` or `-(x + 1)`) can invoke undefined behavior due to signed integer overflow. * In the expression `-x - 1`, the `-x` portion overflows if `x` is `INT_MIN`. * In the expression `-(x + 1)`, the `x + 1` portion overflows if `x` is `INT_MAX`. In contrast, the bitwise operation `~x` operates solely on the bit representation. It is always well-defined for any valid integer value and never triggers arithmetic overflow.

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