> ## 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 Inequality The `!=` (inequality) operator is a binary equality operator in C that evaluates whether two operands are not equal in value. It yields an integer result of `1` (representing true) if the operands differ, and `0` (representing false) if they evaluate to the same value. ```c theme={"dark"} operand1 != operand2 ``` ## Return Type and Evaluation Unlike languages with a dedicated boolean primitive built into the core syntax, the `!=` operator in C strictly evaluates to an `int`. * **Precedence:** In the C standard (C11 Section 6.5.9), `!=` is strictly classified as an equality operator, which places it at a lower precedence level than relational operators (`<`, `<=`, `>`, `>=`), arithmetic operators, bitwise NOT (`~`), and bitwise shift operators (`<<`, `>>`). It has higher precedence than bitwise AND (`&`), XOR (`^`), OR (`|`), and logical operators (`&&`, `||`). * **Associativity:** Left-to-right. ## Type Conversions and Coercion When `operand1` and `operand2` are of different types, the C compiler applies implicit type promotion rules before performing the comparison: 1. **Usual Arithmetic Conversions:** If both operands are arithmetic types (integer or floating-point), they are promoted to a common type. For example, if comparing an `int` and a `double`, the `int` is implicitly promoted to a `double` before the inequality check occurs. 2. **Pointer Comparison:** The `!=` operator can compare two pointers. This is strictly valid only if: * Both pointers point to compatible types. * One operand is a pointer to an object or incomplete type and the other is a pointer to `void`. * One operand is a pointer and the other is a null pointer constant (e.g., `NULL` or `0`). 3. **Structs and Unions:** The `!=` operator cannot be used directly on `struct` or `union` types. The compiler will throw an error as C does not support implicit deep-comparison of composite data types. ## Floating-Point Mechanics When utilizing `!=` with IEEE 754 floating-point numbers (`float`, `double`), specific hardware-level rules apply: * **Negative Zero:** `0.0 != -0.0` evaluates to `0` (they are considered equal). * **NaN (Not a Number):** If either operand is `NaN`, the `!=` operator *always* evaluates to `1`. Consequently, `NaN != NaN` evaluates to `1`.

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