Are you ready to take your C programming skills to the next level? Understanding and effectively using the basic data types in c is a crucial part of writing efficient and high-quality code.

In the C programming language, data types are used to define the type of a variable while a variable is a storage location in a program that can hold a value.

The data type determines what kind of value the variable can hold.

Before we move on, it might be helpful to check out these additional resources on How to Get Started with C Programming for Beginners

Basic Data Types in C

Easily find the C programming data types you need with this convenient table

TypeSize (bytes)Format Specifier
intat least 2, usually 4%d, %i
short int2 usually%hd
unsigned intat least 2, usually 4%u
long intat least 4, usually 8%ld, %li
long long intat least 8%lld, %lli
unsigned long intat least 4%lu
unsigned long long intat least 8%llu
signed char1%c
unsigned char1%c
long doubleat least 10, usually 12 or 16%Lf


The int data type in C is used to store integer values (whole numbers eg. 3, 0, -4). It is usually two or four bytes in size, depending on the system.

To declare an integer value, we use the int keyword

int age;
#include <stdio.h>

int main() {
  int age;  // Declare a variable named "age" of type int
  age = 30;  // Assign the value 30 to the variable "age"

  printf("Age: %d\n", age);  // Print the value of the variable "age"

  return 0;

This program will print “Age: 30” to the console.

Age: 30

The int data type can hold any whole number value within a certain range, which depends on the size of the int data type on the system.


char data type is used to represent a single character. It is usually stored as a 1 – byte integer, which means it can hold any value between -128 and 127 (inclusive).

char alphabet = ‘A’;

The value of the data type char must be enclosed in a single quote.

char data type can also be used to store strings in C. A string is a sequence of characters and is represented as an array of char elements.

For example:

#include <stdio.h>

int main(void) {
  char name[10] = "Roland";  // Declare a char array named "name" and assign it the string "Roland"
  printf("Name: %s\n", name);  // Print the value of the variable "name"
  return 0;

This program will print “Name: Roland” to the console.

Name: Roland

float and double:

In C, the float and double data types are used to represent floating-point numbers.

A floating-point number is a numeric value with a decimal point, such as 3.14 or -2.648.

The float data type is a single-precision floating-point type, which means it can store numbers up to 6 significant digits.

#include <stdio.h>

int main(void) {
  float price = 19.998474;  // Declare a variable named "price" of type float and assign it the value 19.998474

  printf("Price: $%.2f\n", price);  // Print the value of the variable "price" with two decimal places

  return 0;

This program will print “Price: $19.99” to the console.

Price: $19.99

Note that the %.2f format specifier is used to print a floating-point value in the printf function. The .2 indicates that the value should be printed with two decimal places. The f indicates that the value is of type float.

The double data type is a double precision floating point type, which means it can store numbers up to 15 significant digits.

double price = 8945.34544;

In general, double has a higher precision than float, which means it can represent a wider range of numbers with greater accuracy.

However, double also requires more memory to store a value and may be slower to perform arithmetic operations than float.

You should use float when you need to store small or moderate-sized numbers with a limited number of significant digits and use double when you need to store larger numbers or numbers with a greater degree of precision.


In C, the void data type is used to represent the absence of a value or type. Use it when a function is not returning anything.

Note that you cannot create variables of the type void.

Here is an example of a function that uses the void data type as its return type:

#include <stdio.h>

// Declare a function that does not return a value and does not take any arguments

void printMessage(void){
     printf("Hello, world!\n");
int main(void){
    // Call the function
    return 0;

In the above example, the printMessage function is declared as taking no arguments (indicated by the void in the function’s parameter list) and returning no value (indicated by the void before the function’s name).

The main function calls the printMessage function, which simply prints a message to the screen.

short and long:

The short data type is used to represent small integers, while the long data type is used to represent larger integers.

A short integer uses fewer bits than a long integer, so it can represent a smaller range of values.

In general, you should use the short data type if you need to save memory and you are sure that the values you are working with will fit within the range of a short.

On the other hand, you should use the long data type if you need to represent larger values or if you are not sure about the range of values you will be working with.

signed and unsigned:

In C, the signed and unsigned keywords are used to specify the range of values that a variable of integer type can represent.

A signed integer is a type of integer that can represent both positive and negative values.

signed int a = 20 // can hold both positive and negative values
signed int b = -10 

An unsigned integer is a type of integer that can only represent positive values.

unsigned int a = 20 // valid - can hold only positive values
unsigned int b = -10 // Invalid - can not hold negative values

The range of values that can be represented by a signed int or unsigned int in C depends on the number of bits used to store the value, which is determined by the implementation of the compiler being used.

In most cases, a signed int in C will use at least 16 bits, which allows it to represent values ranging from -32768 to 32767.

An unsigned int that uses 16 bits can represent values ranging from 0 to 65535. Some implementations may use more bits, such as 32 bits, which would allow the signed int and unsigned int to represent a wider range of values.

Derived Data Types

In C programming language, derived data types are data types that are derived from the fundamental data types. Derived data types allow you to create new data types that are more specific or complex than the fundamental data types.

There are several types of derived data types in C, including:

  1. Arrays: An array is a collection of variables of the same data type that are stored in contiguous memory locations and can be accessed using a single name and an index. For example, you could declare an array of integers as follows: int my_array[5];.
  2. Pointers: A pointer is a variable that stores the memory address of another variable. Reference and manipulate variables indirectly using pointers. For example, you could declare a pointer to an integer as follows: int *my_ptr;.
  3. Structures: Group together variables of different data types under a single name using a structure. Structures allow you to create complex data types that can represent more information than a single variable.
  4. Enumerations: An enumeration is a data type that consists of a set of named constants. Use enumerations to create symbolic names for a set of integer values.

Easily Check the Size of a Variable with the sizeof() Operator

In the C programming language, you can use the sizeof operator to determine the size in bytes of a data type or a variable. The sizeof operator returns the size in bytes as an unsigned integer value.

Here is an example of how you can use the sizeof operator to check the size of various data types in C:

#include <stdio.h>

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

This code uses the sizeof operator to determine the size in bytes of several fundamental data types: char, short, int, long, long long, float, double, and long double.

The printf function is used to print the size of each data type to the standard output


Mastering C variables and data types is a crucial step in becoming a proficient C programmer.

It requires a combination of dedication, practice, and a passion for problem-solving.

By carefully selecting the appropriate data type for your variables and understanding the underlying mechanics of how they work, you can write efficient and effective code.

With time and persistence, you can confidently navigate the world of C programming and take your skills to the next level. So embrace the challenge, dive deep into the details, and let your passion guide you toward mastery.

If you have any questions or comments, please don’t hesitate to leave them in the comments section below.

Our team is always happy to help and we welcome any feedback or suggestions you may have.

Additional Resources