XQA
Back to C Programming
2026-02-047 min read

11.1.1 Basic Integers

Learn 11.1.1 Basic Integers step by step with clear examples and exercises.

Title: Mastering Basic Integers in C Programming

Why This Matters

In this comprehensive lesson, we will delve into the fundamental concept of integers in C programming. Understanding basic integers is essential for writing efficient and effective code, as they form the backbone of most numerical operations. This knowledge is crucial for acing coding interviews, debugging real-world issues, and creating robust programs that handle integer data correctly.

Prerequisites

To follow this lesson, you should have a basic understanding of:

  • C programming basics (variables, operators, control structures)
  • Understanding the difference between an integer and a float
  • Familiarity with variables and data types in C

Additional Resources

If you need to refresh your knowledge on the prerequisites, consider reviewing these resources:

Core Concept

In C programming, integers are whole numbers without fractional parts. They can be positive or negative, and their range depends on the size of the integer variable. The most commonly used integer data types in C are int, short, and long.

  • int: This is the default integer data type in C. It can store values between -2147483648 and 2147483647 on a 32-bit system, and between -9223372036854775808 and 9223372036854775807 on a 64-bit system.
  • short: This data type is used when you want to store smaller integers, as it requires less memory than int. The range of values for a short integer depends on the system but can typically store values between -32768 and 32767.
  • long: This data type is used when you need to store larger integers or when precision is important, as it requires more memory than int. The range of values for a long integer depends on the system but can typically store values between -2147483648 and 2147483647 on a 32-bit system and between -9223372036854775808 and 9223372036854775807 on a 64-bit system.

Additional Information

  • long long int: This data type is used when you need to store even larger integers or when precision is critical, as it requires more memory than long. The range of values for a long long int depends on the system but can typically store values between -9223372036854775808 and 9223372036854775807.
  • unsigned int, unsigned short, and unsigned long: These data types store only non-negative values. They are useful when you know that a variable will never be negative or when you want to avoid potential sign-related issues.

Worked Example

Let's write a simple C program that demonstrates the use of basic integers:

#include <stdio.h>

int main() {
int a = 10;
short b = 255;
long c = 987654321;
unsigned int d = 4294967295; // The maximum value for an unsigned int on a 32-bit system.

printf("The value of variable 'a' is: %d\n", a);
printf("The value of variable 'b' is: %hd\n", b);
printf("The value of variable 'c' is: %ld\n", c);
printf("The value of variable 'd' is: %u\n", d);

return 0;
}

In this example, we declare four variables of different integer data types (int, short, long, and unsigned int) and assign them values. We then use the printf() function to print their values. When you run this program, it will output:

The value of variable 'a' is: 10
The value of variable 'b' is: 255
The value of variable 'c' is: 987654321
The value of variable 'd' is: 4294967295

Common Mistakes

  1. Using the wrong data type: Using a smaller data type (like short) when you need to store a larger integer can lead to unexpected results or even program crashes due to overflow. Conversely, using a larger data type (like long) when you only need to store a small integer wastes memory and may slow down your program.
  2. Integer overflow: Integer overflow occurs when the value assigned to an integer variable exceeds its maximum capacity. This can lead to unexpected results or even program crashes. To avoid this, make sure to use the appropriate data type for your needs and handle potential overflows using techniques such as modulus arithmetic or checking the sign of the result.
  3. Confusing signed and unsigned integers: In C, integer variables can be either signed (storing both positive and negative values) or unsigned (only storing non-negative values). Be aware of the differences between them, as they can affect the range of values your program can handle.
  4. Not handling edge cases: When working with integers, it's essential to consider edge cases such as minimum and maximum values, overflow, and underflow. Failing to do so can lead to unexpected behavior in your code.

Common Mistakes - Additional Information

  • Using the wrong data type for arithmetic operations: Using a smaller data type (like short) for arithmetic operations with larger numbers can result in unexpected results due to overflow or precision loss. To avoid this, use a larger data type or perform the calculations in a higher-precision data type before converting the result to the desired data type.
  • Not initializing variables: Failing to initialize variables can lead to undefined behavior and hard-to-debug issues. Always make sure to initialize your variables appropriately.

Practice Questions

  1. Write a C program that calculates the sum of two integers entered by the user using int data type.
  2. Modify the worked example to use short and long variables instead of int. What happens when you try to store a value larger than the maximum capacity of short or long?
  3. Write a C program that demonstrates integer overflow using int data type.
  4. Write a C program that calculates the factorial of an integer entered by the user using long long int data type to avoid potential overflows.
  5. Write a C program that finds the maximum and minimum values that can be stored in variables of type char, short, int, long, and long long int.
  6. Write a C program that calculates the average of three integers entered by the user using the appropriate data type for each number to minimize precision loss.
  7. Write a C program that finds the largest prime number less than or equal to a given integer entered by the user, using an unsigned long variable to store the result.
  8. Write a C program that checks if a given number is even or odd using the modulus operator and handles edge cases such as zero.
  9. Write a C program that finds the greatest common divisor (GCD) of two integers entered by the user, using an unsigned long variable to store the result.
  10. Write a C program that calculates the Fibonacci sequence up to a given number entered by the user, handling potential overflow issues using appropriate data types and techniques.

FAQ

  1. What is the difference between signed and unsigned integers in C?
  • Signed integers can store both positive and negative values, while unsigned integers can only store non-negative values. The range of values for a signed integer depends on its size (int, short, or long), whereas an unsigned integer's range is twice as large due to the absence of negative numbers.
  1. What happens when you try to assign a value larger than the maximum capacity of a data type in C?
  • If you assign a value larger than the maximum capacity of a data type, it will result in integer overflow, leading to unexpected results or even program crashes. To avoid this, use a larger data type or handle potential overflows using techniques such as modulus arithmetic or checking the sign of the result.
  1. Why would I want to use smaller data types like short instead of int in C?
  • Using smaller data types like short can help save memory when you need to store smaller integers, as they require less memory than int. However, be aware that using a smaller data type may affect the precision and range of your program's integer operations.
  1. Why are unsigned integers useful in C?
  • Unsigned integers can be helpful when you know that a variable will never be negative or when you want to avoid potential sign-related issues. They offer twice the range of signed integers, making them suitable for certain applications where large positive numbers are required.
  1. What is integer overflow in C?
  • Integer overflow occurs when the value assigned to an integer variable exceeds its maximum capacity. This can lead to unexpected results or even program crashes. To avoid this, make sure to use the appropriate data type for your needs and handle potential overflows using techniques such as modulus arithmetic or checking the sign of the result.
  1. What is the difference between int and long int in C?
  • Both int and long int can store integers, but long int offers a larger range of values due to its increased memory allocation. Use long int when you need to store larger integers or when precision is critical.