XQA
Back to C Programming
2026-07-128 min read

Basic types

Learn Basic types step by step with clear examples and exercises.

Why This Matters

Understanding C programming's basic data types is crucial for writing efficient and error-free code. A good grasp of these data types will make it easier to understand more complex programs, prepare you for coding interviews or real-world projects, and help avoid runtime errors that can cause your program to behave unexpectedly.

Why This Matters (Expanded)

In addition to the reasons mentioned above, understanding C's basic data types is essential for optimizing memory usage and performance in your programs. By choosing the appropriate data type for each variable, you can minimize memory consumption and ensure that your program runs smoothly even on resource-constrained systems. This knowledge also lays the foundation for working with more complex data structures such as arrays, pointers, and structures.

Prerequisites

To fully appreciate this lesson, you should have a basic understanding of the following topics:

  1. Basics of C programming (variables, operators, etc.)
  2. Control structures (if...else, loops)
  3. Basic file I/O operations
  4. Understanding how to compile and run C programs on your system
  5. Familiarity with basic mathematical concepts such as addition, subtraction, multiplication, division, modulo, and exponentiation
  6. A general understanding of computer memory and its organization (optional but recommended)

Core Concept

Data Types in C Programming

In C programming, data types are declarations for variables that determine the type and size of data associated with them. This allows the compiler to allocate appropriate memory for each variable and ensure that operations on these variables are performed correctly. For example:

int myVar; // Here, myVar is a variable of int (integer) type. The size of int is 4 bytes.

Here's a table containing commonly used types in C programming for quick access:

| Type | Size (bytes) | Format Specifier |

|--------------|-------------|------------------|

| char | 1 | %c |

| unsigned char| 1 | %hhu |

| short int | 2 | %hd |

| unsigned short int| 2 | %hu |

| int | 4 | %d |

| unsigned int | 4 | %u |

| long | 4 or 8 | %ld |

| unsigned long| 4 or 8 | %lu |

| float | 4 | %f |

| double | 8 | %lf |

| long double | 16 | %Lf |

Characters and String Literals

In C, a character is represented by the char data type. ASCII values are commonly used for characters in English-speaking countries, while other encodings such as UTF-8 may be used for international character sets.

A string literal (also known as a character constant) is enclosed in double quotes and represents an array of characters terminated by the null character (\0). For example:

char myChar = 'A'; // This is a single character
char myString[] = "Hello, World!"; // This is a string literal containing multiple characters

Integers and Floating-Point Numbers

Integers are whole numbers that can be either signed or unsigned. Signed integers can have positive or negative values, while unsigned integers only have positive values. The int, long, and unsigned long data types can represent both signed and unsigned integers, depending on your compiler settings.

Floating-point numbers are real numbers that can have fractional parts. The float, double, and long double data types are used to represent floating-point numbers in C programming.

Other Data Types

C also provides other data types such as pointers, arrays, structures, unions, and enumerations. These will be covered in future lessons.

Common Mistakes

  1. Not initializing variables: In C, uninitialized variables have indeterminate values. To avoid this, always initialize your variables before using them:
int myVar; // This variable has an indeterminate value
int myVar = 0; // This variable is initialized to 0
  1. Confusing char and unsigned char: The char type can hold both character values (ASCII codes) and integer values, while unsigned char only holds integer values between 0 and 255. Be careful when using these types:
char myChar = 'A'; // This is a character value
unsigned char myUnsignedChar = 256; // This will cause a compile error
  1. Not understanding signed and unsigned integers: In C, the int type can be either signed or unsigned, depending on your compiler settings. Signed integers can hold values between -(2^n-1) and (2^n-1)-1, while unsigned integers can hold values between 0 and (2^n)-1. Be mindful of this when writing code that involves integer arithmetic:
int mySignedInt = -1; // This variable has the value -1
unsigned int myUnsignedInt = 4294967295; // This variable has the maximum possible value for an unsigned 32-bit integer

Worked Example

Let's write a simple C program that demonstrates using basic types and performs some basic arithmetic operations:

#include <stdio.h>

int main() {
char myChar = 'A'; // This is a single character
unsigned char myUnsignedChar = 255; // This is an unsigned integer with the maximum possible value for an 8-bit integer
short int myShortInt = -32768; // This is a signed integer with the minimum possible value for a 16-bit integer
unsigned short int myUnsignedShortInt = 65535; // This is an unsigned integer with the maximum possible value for a 16-bit integer
int myInt = -2147483648; // This is a signed integer with the minimum possible value for a 32-bit integer
unsigned int myUnsignedInt = 4294967295; // This is an unsigned integer with the maximum possible value for a 32-bit integer
long myLong = -9223372036854775808; // This is a signed integer with the minimum possible value for a 64-bit integer
unsigned long myUnsignedLong = 18446744073709551615; // This is an unsigned integer with the maximum possible value for a 64-bit integer
float myFloat = -3.14f; // This is a floating-point number with the value -3.14
double myDouble = -1234567.89; // This is a floating-point number with the value -1,234,567.89
long double myLongDouble = -0.0000000000000000000000000000000; // This is a floating-point number with the smallest possible value for a 128-bit floating-point type

printf("Character: %c\n", myChar);
printf("Unsigned char: %hhu\n", myUnsignedChar);
printf("Short int: %hd\n", myShortInt);
printf("Unsigned short int: %hu\n", myUnsignedShortInt);
printf("Integer: %d\n", myInt);
printf("Unsigned integer: %u\n", myUnsignedInt);
printf("Long: %ld\n", myLong);
printf("Unsigned long: %lu\n", myUnsignedLong);
printf("Float: %.2f\n", myFloat);
printf("Double: %.2lf\n", myDouble);
printf("Long double: %.18Lf\n", myLongDouble);

// Perform some arithmetic operations
int result1 = myShortInt + myUnsignedChar; // This will cause a compile error due to integer overflow
unsigned int result2 = (unsigned int)myShortInt + myUnsignedChar; // This is the correct way to perform the addition without causing a compile error
printf("Result of short int + unsigned char: %u\n", result2);

// Demonstrate the modulo operator
int result3 = 10 % 3; // This has the value 1
printf("Result of 10 modulo 3: %d\n", result3);

return 0;
}

Common Mistakes

  1. Not initializing variables: In C, uninitialized variables have indeterminate values. To avoid this, always initialize your variables before using them:
int myVar; // This variable has an indeterminate value
int myVar = 0; // This variable is initialized to 0
  1. Confusing char and unsigned char: The char type can hold both character values (ASCII codes) and integer values, while unsigned char only holds integer values between 0 and 255. Be careful when using these types:
char myChar = 'A'; // This is a character value
unsigned char myUnsignedChar = 256; // This will cause a compile error
  1. Not understanding signed and unsigned integers: In C, the int type can be either signed or unsigned, depending on your compiler settings. Signed integers can hold values between -(2^n-1) and (2^n-1)-1, while unsigned integers can hold values between 0 and (2^n)-1. Be mindful of this when writing code that involves integer arithmetic:
int mySignedInt = -1; // This variable has the value -1
unsigned int myUnsignedInt = 4294967295; // This variable has the maximum possible value for an unsigned 32-bit integer

Practice Questions

  1. Write a program that declares and initializes variables of all basic data types in C, then prints their values using the appropriate format specifiers.
  2. Write a program that takes two integers as input, checks if they are equal, and prints the result. Handle both signed and unsigned integers.
  3. Write a program that calculates the factorial of a given number (up to 10) using recursion and different data types for the factorial variable. Test your program with various inputs and compare the performance differences between int, long, and long long.
  4. Write a program that finds the smallest positive integer that cannot be represented as a uint32_t (unsigned 32-bit integer).
  5. Write a program that calculates the sum of all numbers from 1 to 100 using different data types for the accumulator variable (int, long, and long long). Compare the performance differences between the three data types.

FAQ

  1. Why does C have so many integer data types?
  • Different data types allow for better memory management, as smaller data types consume less memory than larger ones. Additionally, signed and unsigned integers provide flexibility in handling both positive and negative numbers.
  1. What is the difference between char and unsigned char in C?
  • char can hold both character values (ASCII codes) and integer values, while unsigned char only holds integer values between 0 and 255. Be careful when using these types to avoid unexpected results.
  1. Why does my program crash with an "integer overflow" error?
  • Integer overflow occurs when a value exceeds the maximum representable value for its data type. To prevent this, use appropriate data types and handle potential overflow situations carefully, such as by using unsigned integers or performing checks before operations that might cause overflow.
  1. Why does my program print unexpected results when I mix signed and unsigned integers?
  • When mixing signed and unsigned integers in arithmetic operations, the compiler may perform implicit type conversions that can lead to unexpected results. To avoid this, ensure that all operands are of the same data type or use explicit casts when necessary.
  1. Why does my program print a strange value for the smallest positive integer that cannot be represented as a uint32_t?
  • The smallest positive integer that cannot be represented as a uint32_t is 2^32 (4,294,967,296). However, due to the way computers represent numbers internally, the smallest number that cannot be represented as a uint32_t is actually one greater: 2^32 + 1. This value is known as the first prime number after 4,294,967,295 (the largest representable uint32_t).