Chapter 5: Data Type Conversion in C Language

In C language, data type conversion (also known as type conversion) is the process of converting a value of one data type to another data type. C language provides two types of conversions:implicit type conversion and explicit type conversion. Understanding these conversion methods is crucial for writing robust code.

1. Implicit Type Conversion

Implicit type conversion is a type conversion that is automatically performed by the compiler. It usually occurs when operands of different types are involved in an operation, where the compiler automatically converts the smaller type to the larger type to avoid data loss.

Example:

int a = 5;
float b = 3.14;
float result = a + b;  // int type a is automatically converted to float type

In the above example, the variable a is of int type, and b is of float type. When calculating a + b, a will be automatically converted to float type before the addition operation. This helps avoid errors caused by type mismatches.

Rules for Implicit Type Conversion:

• Integer type to floating-point type: int → float or double.
• Smaller integer type to larger integer type: char → short → int → long → long long.
• Smaller floating-point type to larger floating-point type: float → double.

2. Explicit Type Conversion

Explicit type conversion is a type conversion that is actively performed by the programmer. Explicit type conversion is achieved using parentheses (). Even if the conversion may lead to data loss, the compiler does not report an error but directly performs the conversion.

Example:

double pi = 3.14159;
int pi_int = (int) pi;  // explicitly converts double type to int type

In the above code, pi is a variable of double type, and using (int) explicitly converts pi to int type. This will lose the decimal part and only retain the integer part. After conversion, the value of pi_int will be 3.

Syntax for Explicit Type Conversion:

(type) expression

• type: The target data type, indicating the data type you want to convert to.
• expression: The data that needs to be converted.

3. Type Conversion Rules

In C language, when performing type conversion, certain rules are followed to ensure the correctness of the data conversion process. These rules determine the potential data loss or precision issues that may occur during conversions between different types.

a. Conversion from Integer to Floating Point

When an integer type is converted to a floating-point type, the integer value is retained but becomes a floating-point type, with increased precision.

int x = 10;
float y = (float) x;  // x is converted to floating-point 10.0

b. Conversion from Floating Point to Integer

When a floating-point number is converted to an integer, the decimal part is usually lost, retaining only the integer part. The conversion result is rounded towards zero.

double x = 10.75;
int y = (int) x;  // y's value is 10, decimal part is lost

c. Conversion from Smaller Type to Larger Type

When converting from a smaller type (such as char or short) to a larger type (such as int or long), data is usually not lost.

short s = 32000;
int i = s;  // short type is converted to int type, no data loss

d. Conversion from Larger Type to Smaller Type

If a larger type (such as long or double) is converted to a smaller type (such as short or char), it may lead to data loss or overflow.

long l = 100000;
short s = (short) l;  // data overflow, result may be negative

4. Conversion Between Characters and Integers

In C language, the character type char is actually an integer type (usually a subtype of int). Therefore, character values can be converted to and from integers, or calculated using the ASCII values of characters.

Example:

char c = 'A';
int i = (int) c;  // ASCII value of 'A' is 65
printf("ASCII value of 'A': %d\n", i);  // outputs 65

Reverse Conversion:

int i = 65;
char c = (char) i;  // converts integer 65 to character 'A'
printf("Character: %c\n", c);  // outputs 'A'

5. Type Conversion and Function Parameters

When passing function parameters, C language performs implicit type conversion as needed, or explicit type conversion can be used when calling the function.

Example: Implicit Conversion

void printSum(double a, double b) {
    printf("Sum: %.2f\n", a + b);
}

int main() {
    int x = 5, y = 10;
    printSum(x, y);  // automatically converts int type x and y to double type
    return 0;
}

Example: Explicit Conversion

void printSum(double a, double b) {
    printf("Sum: %.2f\n", a + b);
}

int main() {
    int x = 5, y = 10;
    printSum((double)x, (double)y);  // explicitly converts x and y to double type
    return 0;
}

6. Conclusion

Type Conversion Method	Description	Example
Implicit Type Conversion	Type conversion performed automatically by the compiler, usually occurring when data types do not match.	`<span>int a = 5; float b = 3.14; float c = a + b;</span>`
Explicit Type Conversion	Type conversion performed manually by the programmer, using `<span>(type)</span>` syntax.	`<span>int x = (int) 3.14;</span>`
Implicit Conversion Rules	The compiler automatically converts smaller types to larger types to avoid data loss.	`<span>int a = 10; float b = a;</span>`
Explicit Conversion Rules	Manual type change can be achieved through explicit conversion, but information may be lost.	`<span>double x = 3.14; int y = (int) x;</span>`
Character and Integer Conversion	`<span>char</span>` and integers can be directly converted, with characters corresponding to their ASCII values.	`<span>char c = 'A'; int i = (int) c;</span>`

Understanding the rules of data type conversion can help us better control data flow, avoid unexpected data loss or overflow issues, and write more stable C language programs. If you have more questions, feel free to ask!