Data types

Alright, let’s dive into data types in C. These are essential because they define what kind of data a variable can hold and how much memory it takes up. Let's break them down!

1. Basic Data Types in C

C provides several standard data types:

Data Type	Description	Size (bytes)	Range
int	Integer numbers	4	-2,147,483,648 to 2,147,483,647
float	Single-precision floating point	4	±3.4E-38 to ±3.4E+38
double	Double-precision floating point	8	±1.7E-308 to ±1.7E+308
char	Single character	1	0 to 255 (ASCII values)
void	Represents the absence of a value	0	N/A

2. Integer Types

Integers (int) are the most commonly used data type in C. They store whole numbers, both positive and negative. If you need more specific integer types, you can use short, long, and unsigned variations:

• short int: Takes less memory but has a smaller range.

• long int: Takes more memory and has a bigger range.

• unsigned int: Can only store positive numbers but gives you more range in the positive side.

Example:

short int a = 10;   // short integer
long int b = 123456789;  // long integer
unsigned int c = 250;   // unsigned integer

3. Floating-Point Types

Floating-point types are used to represent real numbers (numbers with fractions/decimal points).

• float: Single-precision (7 decimal places).

• double: Double-precision (15-16 decimal places). It’s more precise but takes up more memory.

Example:

float height = 5.9;  // float for decimal values
double pi = 3.14159265359;  // double for higher precision

4. Character Type (char)

The char data type stores single characters. In reality, it stores an ASCII value (a numeric code representing characters). A character can be enclosed in single quotes ('A', '5', '?').

Example:

char grade = 'A';  // stores the character 'A'
char symbol = '@';  // stores the character '@'

You can also perform arithmetic operations with char because it’s stored as a number in memory (ASCII value).

Example:

char letter = 'A';  // ASCII value of 'A' is 65
letter = letter + 1;  // Now letter is 'B' (ASCII value 66)

5. Void Type (void)

The void type is used to indicate no value or empty. You’ll mostly see void in:

• Function return types: It tells the function not to return any value.

• Function parameters: Tells the function it doesn’t take any arguments.

Example:

void greet() {
    printf("Hello, world!\n");
}

This function does not return any value (void return type).

6. Modifiers for Data Types

You can modify data types in C to adjust their size and range. Some common modifiers are:

• signed: Default for integers, allows storing negative and positive numbers.

• unsigned: For non-negative numbers only, gives a larger range of positive numbers.

• short: Uses less memory but has a smaller range.

• long: Uses more memory and allows for a larger range.

Example:

unsigned int count = 100;  // count can't be negative
long double precision_value = 3.1415926535;

7. Size of Data Types

The size of each data type depends on the system architecture (32-bit or 64-bit). You can use the sizeof() operator to find out the size of any data type.

Example:

int main() {
    printf("Size of int: %lu bytes\n", sizeof(int));
    printf("Size of float: %lu bytes\n", sizeof(float));
    printf("Size of double: %lu bytes\n", sizeof(double));
    return 0;
}

---

Data Type Cheat Sheet

Here’s a quick summary of common data types in C:

Data Type	Size (bytes)	Format Specifier	When to Use
char	1	%c	Store single characters (1 byte).
signed char	1	%hhi	Same as char, but stores values from -128 to 127.
unsigned char	1	%hhu	Stores positive small integers (0 to 255).
short / short int	2	%hd	For small integer values (-32,768 to 32,767).
unsigned short	2	%hu	For small non-negative integers (0 to 65,535).
int	4	%d, %i	General-purpose integer (-2,147,483,648 to 2,147,483,647).
unsigned int	4	%u	For non-negative integers (0 to 4,294,967,295).
long / long int	4 (32-bit), 8 (64-bit)	%ld	Larger integers, used when a broader range than int is needed.
unsigned long	4 (32-bit), 8 (64-bit)	%lu	Non-negative large integers, for bigger numbers than int.
long long / long long int	8	%lld	For extremely large integers (-2^63 to 2^63-1).
unsigned long long	8	%llu	For very large non-negative integers (0 to 2^64-1).
float	4	%f	Single-precision floating-point (decimal) numbers.
double	8	%lf	Double-precision floating-point numbers, more accuracy than float.
long double	12 (or 16)	%Lf	Extended precision floating-point, for higher precision.
_Bool / bool	1	%d	For boolean values (true/false), included in <stdbool.h>.
void	0	N/A	For functions that don't return a value or generic pointers.
size_t	Platform-dependent	%zu	Used for representing sizes, e.g., array indexing.
ptrdiff_t	Platform-dependent	%td	Represents difference between two pointers.
wchar_t	2 or 4	%lc	For wide characters, used in internationalization (Unicode).
intptr_t	Platform-dependent	%td	Integer type capable of holding a pointer.
uintptr_t	Platform-dependent	%tu	Unsigned integer type for holding a pointer.

Special Data Types:

Data Type	Size (bytes)	Format Specifier	When to Use
enum	Varies (depends on compiler)	%d	To define a set of named integral constants (e.g., days of the week).
union	Varies (depends on the largest member)	N/A	When you need to store different types in the same memory space.
struct	Varies	N/A	To group different data types together.
typedef	N/A	N/A	Used to give a new name (alias) to an existing type.

Additional Notes:

• The size of data types like int, long, and float can vary depending on the system's architecture (32-bit vs 64-bit).

• Format specifiers are used for I/O functions like printf and scanf to identify the data type being processed.

• typedef allows you to create your own type names, but it doesn't affect the size or structure of the underlying type.

That should be enough for now!