# Type Casting

Casting in C is a method used to convert a variable from one data type to another. There are two types of casting: implicit casting (automatic conversion) and explicit casting (manual conversion).

### Implicit Casting

When it is necessary and safe to do so, the C compiler automatically performs implicit casting. This usually happens when a variable of a smaller data type (like `int`) is assigned to a variable of a larger data type (like `long`). In such cases, the compiler automatically extends the smaller type to the larger type.

**Example:**

```c
int i = 100;
long l = i;  // Implicit casting from int to long
```

**Bit-Level Explanation:**

* The `int` variable `i` is typically 4 bytes (32 bits) on most systems.
    
* When `i` is assigned to `long l`, which is typically 8 bytes (64 bits), the compiler automatically extends `i` to 64 bits by adding zeros to its binary representation.
    

### Explicit Casting

Explicit casting is when the programmer manually converts data types, and it is necessary when converting a larger data type to a smaller one or when converting between types where automatic conversion is not defined.

**Example:**

```c
double d = 9.5;
int i = (int)d;  // Explicit casting from double to int
```

**Bit-Level Explanation:**

* A `double` is typically 8 bytes (64 bits), holding both the integer and fractional parts.
    
* Casting to `int` (4 bytes, 32 bits) involves truncating the fractional part and potentially some of the integer part if the number is too large for an `int`.
    

**Sample Code with Implicit and Explicit Casting:**

```c
#include <stdio.h>

int main() {
    // Implicit casting
    int i = 150;
    long l = i;
    printf("Implicit cast (int to long): %ld\n", l);

    // Explicit casting
    double d = 123.456;
    int j = (int)d;
    printf("Explicit cast (double to int): %d\n", j);

    return 0;
}
```

**Expected Output:**

```bash
Implicit cast (int to long): 150
Explicit cast (double to int): 123
```

### What Happens at the Bit Level

1. **Implicit Casting (**`int` to `long`):
    
    * `i` (32 bits) is extended to 64 bits. If `i` is positive, zeros are added to the left. If `i` is negative, the sign bit (leftmost bit) is extended.
        
    * This process preserves the numerical value while changing the data type.
        
2. **Explicit Casting (**`double` to `int`):
    
    * The `double` value is truncated to fit into an `int`. This means the fractional part is discarded, and if the integer part is too large for an `int`, it gets truncated.
        
    * This process can lead to loss of information and potential overflow issues.
        

Understanding casting is essential for efficient and error-free programming in C, especially when dealing with different data types and hardware-level operations.