C Data types

In the C programming language, data types are used to define the type of data that a variable can hold. C provides a variety of data types to suit different needs. Here are some common C data types:

1. int: This is used to store integer values (whole numbers). It can be signed (positive and negative values) or unsigned (only non-negative values).


int age = 30;

Here's an illustration of how to use the int data type in C:


#include <stdio.h>

int main() {
    // Declare an integer variable named 'age' and assign it a value
    int age = 30;

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

    // Perform arithmetic operations with 'age'
    int nextYearAge = age + 1;
    int doubleAge = age * 2;
    int halfAge = age / 2;

    // Print the results of the arithmetic operations
    printf("Age next year: %d\n", nextYearAge);
    printf("Double age: %d\n", doubleAge);
    printf("Half age: %d\n", halfAge);

    return 0;
}

In this example:

We include the <stdio.h> header to use the printf function for output.
We declare an integer variable named age and initialize it with the value 30.
We print the value of the age variable using printf.
We perform some basic arithmetic operations with the age variable, such as addition, multiplication, and division, and store the results in new variables (nextYearAge, doubleAge, and halfAge).
We print the results of these arithmetic operations using printf.

When you run this program, it will output:


Age: 30
Age next year: 31
Double age: 60
Half age: 15

This illustrates how the int data type is used to store and manipulate integer values in C.

2. char: This is used to store single characters, such as letters or symbols.


char grade = 'A';

Here's an illustration of how to use the char data type in C:


#include <stdio.h>

int main() {
    // Declare a character variable named 'grade' and assign it a character value
    char grade = 'A';

    // Print the value of the 'grade' variable
    printf("Grade: %c\n", grade);

    return 0;
}

In this example:

We include the <stdio.h> header to use the printf function for output.
We declare a character variable named grade and initialize it with the character value 'A'.
We print the value of the grade variable using printf.

When you run this program, it will output:


Grade: A

This illustrates how the char data type is used to store and represent single character values in C. In this case, we've stored the character 'A' in the grade variable.

3. float: This is used to store floating-point numbers, which are numbers with a decimal point.


float temperature = 98.6;

Here's an illustration of how to use the float data type in C:


#include <stdio.h>

int main() {
    // Declare a floating-point variable named 'temperature' and assign it a value
    float temperature = 98.6;

    // Print the value of the 'temperature' variable
    printf("Temperature: %.2f\n", temperature);

    return 0;
}

In this example:

We include the <stdio.h> header to use the printf function for output.
We declare a floating-point variable named temperature and initialize it with the value 98.6, which represents a temperature in degrees Fahrenheit.
We print the value of the temperature variable using printf, and we use the %.2f format specifier to display the floating-point value with two decimal places.

When you run this program, it will output:


Temperature: 98.60

This illustrates how the float data type is used to store and represent floating-point (decimal) values in C. In this case, we've stored the temperature value 98.6 in the temperature variable.

4. double: This is used to store double-precision floating-point numbers, which can hold larger and more precise floating-point values compared to float.


double pi = 3.14159265359;

Here's an illustration of how to use the double data type in C:


#include <stdio.h>

int main() {
    // Declare a double-precision floating-point variable named 'pi' and assign it a value
    double pi = 3.14159265359;

    // Print the value of the 'pi' variable
    printf("Value of pi: %.10lf\n", pi);

    return 0;
}

In this example:

We include the <stdio.h> header to use the printf function for output.
We declare a double-precision floating-point variable named pi and initialize it with the value 3.14159265359.
We print the value of the pi variable using printf, and we use the %.10lf format specifier to display the double-precision floating-point value with ten decimal places.

When you run this program, it will output:


Value of pi: 3.1415926536

This illustrates how the double data type is used to store and represent double-precision floating-point (decimal) values in C. In this case, we've stored the value of pi with high precision in the pi variable.

5. short: This is a data type for short integers, which typically use less memory than regular int.


short x = 10;

Here's an illustration of how to use the short data type in C:


#include <stdio.h>

int main() {
    // Declare a short integer variable named 'x' and assign it a value
    short x = 32767; // This is the maximum value a short can hold

    // Print the value of the 'x' variable
    printf("Value of x: %d\n", x);

    return 0;
}

In this example:

We include the <stdio.h> header to use the printf function for output.
We declare a short integer variable named x and initialize it with the value 32767. This is the maximum value that a short can hold on most systems.
We print the value of the x variable using printf.

When you run this program, it will output:


Value of x: 32767

This illustrates how the short data type is used to store short integer values in C. A short typically uses less memory than a regular int, but it has a limited range compared to an int. In this case, we've stored the maximum value that a short can hold in the x variable.

6. long: This is used to store long integers, which can represent larger values than regular int.


long population = 8000000000L;

Here's an illustration of how to use the long data type in C:


#include <stdio.h>

int main() {
    // Declare a long integer variable named 'population' and assign it a value
    long population = 8000000000L; // 8 billion (L is used to specify a long literal)

    // Print the value of the 'population' variable
    printf("World population: %ld\n", population);

    return 0;
}

In this example:

We include the <stdio.h> header to use the printf function for output.
We declare a long integer variable named population and initialize it with the value 8000000000L. The L at the end of the literal is used to specify that this is a long integer literal.
We print the value of the population variable using printf, and we use the %ld format specifier to display the long integer value.

When you run this program, it will output:


World population: 8000000000

This illustrates how the long data type is used to store long integer values in C. The long data type can represent larger values than a regular int, making it suitable for storing large numbers like the world population in this example.

7. unsigned: This is used to declare an integer as unsigned, meaning it can only hold non-negative values.


unsigned int count = 100;

Here's an illustration of how to use the unsigned data type in C:


#include <stdio.h>

int main() {
    // Declare an unsigned integer variable named 'count' and assign it a value
    unsigned int count = 100;

    // Print the value of the 'count' variable
    printf("Count: %u\n", count);

    return 0;
}

In this example:

We include the <stdio.h> header to use the printf function for output.
We declare an unsigned integer variable named count and initialize it with the value 100. The unsigned keyword is used to indicate that this variable can only hold non-negative values.
We print the value of the count variable using printf, and we use the %u format specifier to display the unsigned integer value.

When you run this program, it will output:


Count: 100

This illustrates how the unsigned data type is used to declare an integer variable that can only store non-negative values in C. In this case, we've stored the value 100 in the count variable.

8. bool: This is used to store boolean values, which can be either true or false. In C, 0 represents false, and any non-zero value represents true.


bool isStudent = 1; // true

Here's an illustration of how to use the _Bool data type in C, which is used to store boolean values:


#include <stdio.h>

int main() {
    // Declare a boolean variable named 'isStudent' and assign it a value
    bool isStudent = 1; // 1 represents true

    // Print the value of the 'isStudent' variable
    if (isStudent) {
        printf("I am a student.\n");
    } else {
        printf("I am not a student.\n");
    }

    return 0;
}

In this example:

We include the <stdio.h> header to use the printf function for output.
We declare a bool variable named isStudent and initialize it with the value 1, which represents true in C. bool variables can only hold 0 (false) or 1 (true).
We print a message based on the value of the isStudent variable using an if statement. If isStudent is 1, it prints "I am a student," otherwise, it prints "I am not a student."

When you run this program, it will output:


I am a student.

This illustrates how the bool data type is used to store boolean values (true or false) in C. In this case, we've used 1 to represent that the person is a student.

9. enum: Enums are used to define a set of named integer constants. They are often used to improve code readability by giving meaningful names to integer values.


enum Days { Monday, Tuesday, Wednesday, Thursday, Friday, Saturday, Sunday };
enum Days today = Wednesday;

Here's an illustration of how to use the enum data type in C:


#include <stdio.h>

// Define an enumeration named 'Days' with named constants for days of the week
enum Days {
    Monday,
    Tuesday,
    Wednesday,
    Thursday,
    Friday,
    Saturday,
    Sunday
};

int main() {
    // Declare a variable of type 'enum Days' and assign it a value
    enum Days today = Wednesday;

    // Print the value of the 'today' variable
    switch (today) {
        case Monday:
            printf("Today is Monday.\n");
            break;
        case Tuesday:
            printf("Today is Tuesday.\n");
            break;
        case Wednesday:
            printf("Today is Wednesday.\n");
            break;
        case Thursday:
            printf("Today is Thursday.\n");
            break;
        case Friday:
            printf("Today is Friday.\n");
            break;
        case Saturday:
            printf("Today is Saturday.\n");
            break;
        case Sunday:
            printf("Today is Sunday.\n");
            break;
        default:
            printf("Invalid day.\n");
            break;
    }

    return 0;
}

In this example:

We include the <stdio.h> header to use the printf function for output.
We define an enumeration named Days using the enum keyword. Inside the enum, we list the named constants for days of the week: Monday, Tuesday, Wednesday, Thursday, Friday, Saturday, and Sunday. These constants represent integer values starting from 0 for Monday.
We declare a variable of type enum Days named today and initialize it with the value Wednesday, indicating that today is Wednesday.
We use a switch statement to check the value of the today variable and print a message based on the day of the week.

When you run this program, it will output:


Today is Wednesday.

This illustrates how the enum data type is used to define a set of named integer constants, which can improve code readability by giving meaningful names to integer values. In this case, we've used it to represent days of the week.

10. struct: A struct is used to create custom composite data types by grouping together variables of different types under a single name.


struct Person {
    char name[50];
    int age;
};

Here's an illustration of how to use the struct data type in C:


#include <stdio.h>
#include <string.h>

// Define a struct named 'Person' to represent a person's name and age
struct Person {
    char name[50];
    int age;
};

int main() {
    // Declare a variable of type 'struct Person'
    struct Person person1;

    // Initialize the 'person1' struct with values
    strcpy(person1.name, "John");
    person1.age = 30;

    // Print the values of the 'person1' struct
    printf("Name: %s\n", person1.name);
    printf("Age: %d\n", person1.age);

    return 0;
}

In this example:

We include the <stdio.h> and <string.h> headers to use the printf function for output and the strcpy function to copy strings.
We define a struct named Person to represent a person's name and age. This struct contains two members: name (an array of characters) and age (an integer).
We declare a variable of type struct Person named person1, which can store both a name and an age.
We initialize the person1 struct with values. We use the strcpy function to copy the name "John" into the name member and assign the age 30 to the age member.
We print the values stored in the person1 struct using printf.

When you run this program, it will output:


Name: John
Age: 30

This illustrates how the struct data type is used to create custom composite data types by grouping together variables of different types under a single name. In this case, we've used it to represent a person's information, including their name and age.

11. union: A union is similar to a struct but allows you to store only one value at a time from its members. This can save memory when you need to store different types of data in the same memory location.


union Data {
	int intValue;
	float floatValue;
	char stringValue[20];
};

C also allows you to create user-defined data types using typedef to give a type a new name, which can improve code readability and maintainability.


typedef int Age;
Age personAge = 25;

It's important to choose the appropriate data type for your variables based on the type of data they will store and the memory requirements of your program. The choice of data type affects the range of values a variable can hold and the memory it consumes.

C Data Types

Subscribe to Newsletter