Primitive data types of C

C's built-in data types that are similar to ones in Java

Syntax	Name	Java's counterpart	use
`char`	character	`byte`	Stores an ASCII code (character) or it can also store a very short integer (−128..127)
`short`	short integer	`short`	uses 2 byte memory, value between −32768 and 32767
`int`	ordinary integer	`int`	uses 4 byte memory, value between −2147483648 and 2147483647
`long`	long integer	`long`	uses 8 bytes memory, value between −9223372036854775808 and 9223372036854775807
`float`	single precision float	`float`	uses 4 byte memory, absolute value between 1.4E−45 and 3.4E38
`double`	double precision float	`double`	uses 8 byte memory, absolute value between 4.9E−324 and 1.8E308
`_Bool`	boolean	`boolean`	true (1) or false (0)

C's built-in data types that do not have an equivalent in Java

Syntax	Name	use
`unsigned char`	Unsigned character	Very short positive integer (0..255)
`unsigned short`	Unsigned short integer	uses 2 byte memory, value between 0 and 65535
`unsigned int`	Unsigned ordinary integer	uses 4 byte memory, value between 0 and 4294967295
`unsigned long`	Unsigned long integer	uses 8 bytes memory, value between 0 and 18446744073709551615
*``**	*Reference type*	Contains a memory address (usually 4 bytes, but 64 bits machines will use 8 bytes)

Operations involving values from same data type
- Just like Java:
- Example:
  This is the similar situation as "adding apples and apples".

Operations involving values from different data types

Just like Java:

Example:

int A; - Defines integer float B, C; - Defines 2 float variables A = 4; // Integer B = 5; // Float C = A + B; - The value of A is converted to FLOAT first - Then the addition is performed

This is the similar situation as "adding apples and oranges". We must convert the apples to oranges first before we can add

Converting between different types of data

Data conversion must take place in the following operations involving different data types:

Binary (arithmethic) operations

Example:

int a; float b; a + b // a in converted to a float

Assignment operations

Example:

int a; float b; a = b ; // b in converted to a int

Making automatic conversion "explicit" with assembler programming

Fact:

We can make the automatic convert by the C compiler explicit by examining the generated assembler code:

The C program:

int x; int y; main(int argc, char * argv[]) { x = y; }

will generate the following Intel Code:

main: .LFB0: .cfi_startproc pushq %rbp .cfi_def_cfa_offset 16 .cfi_offset 6, -16 movq %rsp, %rbp .cfi_def_cfa_register 6 movl %edi, -4(%rbp) movq %rsi, -16(%rbp) movl y(%rip), %eax move y into register "eax" movl %eax, x(%rip) move rigster "eax" to x leave .cfi_def_cfa 7, 8 ret .cfi_endproc

A C program that uses different data types:

int x; float y; main(int argc, char * argv[]) { x = y; }

will contain an appropriate conversion instruction:

main: .LFB0: .cfi_startproc pushq %rbp .cfi_def_cfa_offset 16 .cfi_offset 6, -16 movq %rsp, %rbp .cfi_def_cfa_register 6 movl %edi, -4(%rbp) movq %rsi, -16(%rbp) movss y(%rip), %xmm0 Get y cvttss2si %xmm0, %eax Convert float to int movl %eax, x(%rip) Put in x leave .cfi_def_cfa 7, 8 ret .cfi_endproc

Here's an explanation of the cvttss2si instruction: click here

Example Program: (Demo above code)
- C program Prog file without the need of conversion: click here
- C program Prog file that uses conversion: click here
How to run the program:

Safe conversions in C
- The following conversions are safe in C:
  However:
  This will be explained in the automatic conversion rule next....

Automatic conversion rules in C

Automatic conversion rules of C:

A binary operation using values of 2 different types:

C will automatically perform a safe conversion for the value of the less capable data type to a value of the higher capable data type

Example:

int a; float b; a + b 1. first convert A to float 2. then perform A + B as float + float (Just like Java)

An assignment operation using values of 2 different types:

C will automatically perform a conversion for the value of the LHS data type to a value of the RHS data type
Even if the conversion will cause precision loss (i.e., unsafe) !!!
Example:
Note: this is forbidden in Java !!! (Need a casting operator)

Warning:

In C, you can perform unsafe assignment operations that Java will not allow without using a casting operation

Rationale:

C is designed for system programming; and system programmers are mature programmers who should know the danger of all features of the programming language.
Furthermore, preventive features in programming languages can prevent programmers from performing certain tasks.
Compiler checks for type conflicts often limit the programmers' ability to perform some tasks.
Hence, these checks are omitted.

Conclusion:

Example:

#include <stdio.h> int main(int argc, char* argv[] ) { int i; short s; i = 9827563; s = i; /* Unsafe conversion, allowed in C !!! */ printf( "i = %d , s = %d \n", i, s ); }

Output:

i = 9827563 , s = -2837 (lost of accuracy !)

Example Program: (Demo above code)
- Prog file: click here
How to run the program:

Postlude

Fact:

C will warn you about some conversion between different data types

Example:

int main(int argc, char* argv[] ) { int i = 0; // Integer // i is a number that you can add, subtract, etc int a[5]; // Array of integers // a is the LOCATION (address) of the first elem of the array i = a; // WARNING !! Too different !!! printf("i = %d\n", i); }

Compiler message:

casting2.c: In function 'main': casting2.c:11: warning: assignment makes integer from pointer without a cast

Example Program: (Demo above code)
- Prog file: click here
How to run the program: