# Know your % from close quarters

The `%` operator in C is the modulus operator, which gives the remainder of the division of one number by another. Here are some important considerations when using the `%` operator, especially concerning integer and floating-point values, as well as negative values:

### Modulus with Integers:

1. **Integer Modulus:**
    
    * The `%` operator is primarily designed for integer values, and it returns the remainder of the division.
        
    
    ```c
    int result = 10 % 3; // result is 1 (10 divided by 3 is 3 with a remainder of 1)
    ```
    
2. **Sign of the Result:**
    
    * The sign of the result is the same as the sign of the dividend (the left operand).
        
    
    ```c
    int positiveResult = 10 % 3;    // positiveResult is 1
    int negativeResult = -10 % 3;   // negativeResult is -1
    int mixedResult = 10 % -3;      // mixedResult is 1
    ```
    
3. **Avoiding Division by Zero:**
    
    * As with division, ensure that the divisor is not zero to avoid undefined behavior.
        
    
    ```c
    int numerator = 10;
    int denominator = 0;
    
    if (denominator != 0) {
        int result = numerator % denominator;
    } else {
        // Handle division by zero error
    }
    ```
    

### Modulus with Floating-Point Numbers:

1. **Floating-Point Modulus:**
    
    * The `%` operator is not defined for floating-point numbers in C. If you attempt to use it with floating-point operands, you will likely encounter a compilation error.
        
    
    ```c
    // Error: invalid operands to binary % (have 'float' and 'float')
    float result = 10.5 % 3.2;
    ```
    

### Modulus with Negative Values:

1. **Sign of the Result:**
    
    * The sign of the result is the same as the sign of the dividend (the left operand). This holds true even for negative dividends.
        
    
    ```c
    int negativeDividendResult = -10 % 3;   // result is -1
    int negativeDivisorResult = 10 % -3;   // result is 1
    ```
    
2. **Consistent Sign Convention:**
    
    * The sign convention is consistent with the sign of the dividend, not the divisor.
        
    
    ```c
    int consistentSign = -10 % -3;   // consistentSign is -1
    ```
    

### Modulus and Even/Odd Numbers:

1. **Checking for Even/Odd:**
    
    * Modulus can be used to check whether a number is even or odd.
        
    
    ```c
    int num = 7;
    
    if (num % 2 == 0) {
        // num is even
    } else {
        // num is odd
    }
    ```
    
2. **Alternative for Division by 2:**
    
    * When dealing with powers of 2, using `% 2` is equivalent to bitwise AND with 1 and is often more efficient.
        
    
    ```c
    int num = 16;
    
    if (num % 2 == 0) {
        // num is even
    } else {
        // num is odd
    }
    
    // Equivalent using bitwise AND
    if ((num & 1) == 0) {
        // num is even
    } else {
        // num is odd
    }
    ```
    

In summary, when using the `%` operator in C, be aware of its behavior with integers, its undefined nature with floating-point numbers, and its consistency in sign handling, especially when dealing with negative values. Also, consider using the modulus operator for checking even/odd numbers and alternatives for more efficient code.