C Variables & Data Types: Complete Beginner’s Guide

1. Introduction

The Importance of Variables and Data Types in C

Purpose of This Article

1. What is a variable? – Explanation of declaration, initialization, naming conventions, etc.
2. Classification of data types – Primitive data types (int, float, char, etc.) and derived data types (struct, array, pointer, etc.)
3. Type conversion (casting) – Implicit and explicit type conversions
4. Variable scope and lifetime – Differences between local and global variables
5. Practical selection of data types – Choosing the optimal type based on memory usage and computational precision

When Do You Need to Be Mindful of Variables and Data Types?

Memory Optimization

short num1 = 100;  // 2 bytes (16 bits)
int num2 = 100;    // 4 bytes (32 bits)

Improving Computational Precision

float pi = 3.141592;  // single‑precision floating point (32 bits)
double pi_high = 3.14159265358979;  // double‑precision floating point (64 bits)

Preventing Bugs Through Type Casting

int a = 10;
float b = 3.5;
int result = a + b;  // implicit conversion (result is rounded to int)

float result_correct = (float)a + b;  // correct type conversion

Conclusion

2. What is a Variable?

Basic Concept of Variables

Characteristics of Variables

• Memory area for storing data
• Value can be changed during program execution
• Allocates memory according to the data type (type) of the data

Variable Declaration and Initialization

Basic Variable Declaration Syntax

type variable_name;

Variable Initialization

int num = 10;  // Initialize integer variable num with 10
float pi = 3.14;  // Initialize floating-point variable pi with 3.14
char letter = 'A';  // Initialize character variable letter with 'A'

Variable Types in C

Variable Naming Conventions and Best Practices

Rules for Variable Names in C

• Alphabet (A-Z, a-z)
• Digits (0-9) *but cannot be used at the beginning of a variable name*
• Underscore (_)

• Reserved words (e.g., int, float, return, etc.)
• Special characters (e.g., @, #, $, etc.)
• Digits at the beginning of a variable name

int _value = 10;  // OK
int number1 = 20;  // OK
int 1st_number = 30;  // NG (Variable names cannot start with a digit)
int return = 100;  // NG (Reserved words cannot be used)

Naming for Readability (Best Practices)

int userAge;  // User's age

int a;  // Meaningless

• Give variable names meaningful names
• Use camelCase (e.g., userAge) or snake_case (e.g., user_age) for multiple words
• Avoid abbreviations as much as possible (e.g., use a specific name like numOfStudents)

How to Use Variables (Simple Program)

Sample Code

#include <stdio.h>

int main() {
    int a = 5;
    int b = 10;
    int sum = a + b;  // calculate using variables

    printf("a = %d, b = %d, sum = %dn", a, b, sum);
    return 0;
}

Output

a = 5, b = 10, sum = 15

Summary

• Variables are memory areas for temporarily storing data
• In C, you must specify the data type when declaring a variable
• Variable naming has rules, and naming with readability in mind is recommended
• Using variables makes data management easier

3. Overview of C Language Data Types

What is a Data Type?

Characteristics of C Data Types

int age = 25;        // integer (stores only integer values)
float pi = 3.14;     // floating-point number (can handle decimals)
char letter = 'A';   // character type (stores a single character)

Classification of C Data Types

Basic Data Types

Integer Types

int number = 100;
short smallNumber = 10;
unsigned int positiveOnly = 300;

Floating-Point Types

float pi = 3.14f;  // adding "f" makes it a float type
double precisePi = 3.1415926535;

Character Type

char letter = 'A';
printf("%c", letter);  // outputs A

char letter = 'A';
printf("%d", letter);  // 65 ('A' ASCII code)

Derived Data Types

Criteria for Choosing Data Types

for (unsigned int i = 0; i < 100; i++) {
    printf("%d ", i);
}

Summary

• C data types include basic data types (integer, floating-point, character) and derived data types (arrays, structs, pointers, etc.).
• Choosing the appropriate data type can improve program efficiency.
• Integer types: int; floating-point types are common.
• Utilizing derived data types makes handling complex data structures easier.

4. Basic Data Types (Primitive Types)

What are basic data types?

1. Integer type (Integer)

Kinds of integer types and memory sizes

Example of integer types

#include <stdio.h>

int main() {
    int num = 100;         // General integer type
    short smallNum = 10;   // Small integer (memory saving)
    long bigNum = 1000000; // Large integer
    unsigned int positiveOnly = 300; // Positive integers only

    printf("num: %d, smallNum: %d, bigNum: %ld, positiveOnly: %un", num, shortNum, bigNum, positiveOnly);
    return 0;
}

2. Floating-point type (Floating Point)

Kinds of floating-point types

Example of floating-point types

#include <stdio.h>

int main() {
    float pi = 3.14f;         // Adding "f" makes it a float type
    double precisePi = 3.1415926535;  // Higher-precision double type

    printf("pi (float): %.7fn", pi);
    printf("precisePi (double): %.15lfn", precisePi);
    return 0;
}

3. Character type (Character)

Features of the character type

• Uses 1 byte (8 bits) of memory
• char type uses ASCII codes and is internally treated as an integer

Example of character type

#include <stdio.h>

int main() {
    char letter = 'A';  // Store a character
    printf("letter: %cn", letter);
    printf("ASCII code: %dn", letter);  // 'A' is 65

    return 0;
}

Appropriate selection of basic data types

short smallNum = 32767;  // Save memory

Summary

• Basic data types are the foundation of C programs and handle integers, floating-point numbers, and characters
• Integer types (int, short, long) handle integers, and unsigned (unsigned) can also be used
• Floating-point types (float, double) handle fractional numbers and are chosen based on precision needs
• Character type (char) handles a single character and is stored internally as an integer
• Choosing the appropriate data type improves program efficiency and enables memory savings

5. Derived Data Types

What are Derived Data Types?

1. Array

Array Declaration and Initialization

type array_name[size];

int numbers[5] = {10, 20, 30, 40, 50};

printf("%dn", numbers[0]);  // outputs 10
numbers[1] = 25;  // updates the second element

Multidimensional Arrays (2D Arrays)

int matrix[2][3] = {
    {1, 2, 3},
    {4, 5, 6}
};

2. struct

Defining and Using Structs

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

int main() {
    struct Person person1 = {"Taro", 25, 175.5};
    printf("Name: %s, Age: %d, Height: %.1f cmn", person1.name, person1.age, person1.height);
    return 0;
}

3. union

Defining and Using Unions

union Data {
    int i;
    float f;
};

int main() {
    union Data data;
    data.i = 10;
    printf("Integer: %dn", data.i);

    data.f 3.14;
    printf("Float: %.2fn", data.f);  // at this point, the value of data.i becomes indeterminate

    return 0;
}

4. enum

Defining and Using Enums

enum Color { RED, GREEN, BLUE };

int() {
    enum Color favoriteColor = GREEN;
    printf("Favorite Color: %dn", favoriteColor); // 1 (GREEN is assigned 0 by default, then incremented)
    return 0;
}

5. Pointer

Basics of Pointers

int a = 10;
int *ptr = &a;  // stores the address of 'a' in the pointer

printf("Address of a: %pn", &a);
printf("Pointer Value: %pn", ptr);
printf("Dereferenced Value: %dn", *ptr); // 10

Uses of Pointers

Summary

• Arrays manage data of the same type together
• Structs treat data of different types as a single unit
• Unions are special data types that share memory
• Enums define meaningful constants
• Pointers handle variable addresses

6. Type Modifiers

What are type modifiers?

1. const (declare constants)

Example of using const

#include <stdio.h>

int main() {
    const int MAX_USERS = 100;  // declared as a constant
    printf("Max Users: %dn", MAX_USERS);

    // MAX_USERS = 200;  // Error change value because it's const

    return 0;
}

Applying const to function arguments

void printMessage(const char *message) {
    printf("%sn", message);
    // message[0] = 'H';  // Error! Cannot modify because it's const
}

2. volatile (prevent optimization)

Example of using volatile

#include <stdio.h>

volatile int flag = 0;  // Prevent optimization

int main() {
    while (flag == 0) {
        // Some processing (loop until flag changes)
    }
    printf("Flag changed!n");
    return 0;
}

• Detecting variable changes in multithreaded processing
• Reading hardware registers
• Monitoring variables that may be changed by interrupt handlers

3. restrict (pointer optimization)

Example of using restrict

#include <stdio.h>

void add_arrays(int *restrict a, int *restrict b, int *restrict result, int size) {
    for (int i = 0; i < size; i++) {
        result[i] = a[i] + b[i];
    }
}

• Optimization of pointer arithmetic
• Improved performance of numeric calculations
• Vector operations (SIMD optimization)

4. signed and unsigned (signed and unsigned integers)

Example of signed (signed integer)

int a = -10;  // can also store negative values
printf("%dn", a);  // prints -10

Example of unsigned (unsigned integer)

unsigned int b = 250;
printf("%un", b);  // prints 250

unsigned int c = -10;  // Error! Negative values cannot be stored

• Counters that never use negative values (loop variables, etc.)
• Processing binary data (bitwise operations)
• Efficient use of memory size

int x = -1;
unsigned int y = x;  // Error or unintended result

Summary

7. Type Conversion (Casting)

What is Type Conversion?

1. Implicit Type Conversion (Automatic Conversion)

Rules of Implicit Type Conversion

• Small data type → larger data type is automatically converted
• Integer type → floating-point type is converted
• char → int (treated as ASCII code)

Example of Implicit Type Conversion

#include <stdio.h>

int main() {
    int a = 10;
    float b = a;  // int → float automatic conversion
    printf("b: %.2fn", b);  // output: b: 10.00

    char letter = 'A';
    int asciiValue = letter;  // char → int conversion (ASCII code)
    printf("ASCII value of A: %dn", asciiValue);  // output: ASCII value of A: 65

    return 0;
}

2. Explicit Type Conversion (Casting)

Basic Syntax of Casting

(target data type) value or variable

Example of Using Casting

#include <stdio.h>

int main() {
    int a = 10, b = 3;
    float result = (float)a / b;  // convert int to float
    printf("Result: %.2fn", result);  // output: Result: 3.33

    return 0;
}

3. Cases Where Casting Is Needed

(1) Integer Division

int a = 5, b = 2;
float result = a / b;  // result is 2 (integer division)
float correctResult = (float)a / b;  // correctly becomes 2.5

(2) Floating-point → Integer (fractional part truncation)

float pi = 3.14159;
int truncatedPi = (int)pi;  // becomes 3 (fractional part is truncated)

(3) char → int (convert character to ASCII code)

char letter = 'B';
int ascii = (int)letter;
printf("ASCII Code: %dn", ascii);  // output: ASCII Code: 66

(4) Casting from void * (pointer)

void *ptr;
int num = 10;
ptr = #

int *intPtr = (int *)ptr;  // cast from void * to int *
printf("Value: %dn", *intPtr);  // output: Value: 10

4. Precautions for Type Conversion

(1) Data Precision Loss

float num = 3.9;
int rounded = (int)num;  // result: 3 (fractional part is truncated)

#include <math.h>
int rounded = round(num);  // becomes 4

(2) Beware of conversions between unsigned and signed

unsigned int x = -1;
printf("%un", x);  // output: 4294967295 (32-bit environment)

(3) Converting from larger to smaller type (risk of overflow)

long bigNum = 100000;
short smallNum = (short)bigNum;  // data may not be stored correctly

printf("Size of short: %lu bytesn", sizeof(short));

Summary

8. Variable Scope and Lifetime

What is Variable Scope (Effective Range)?

Types of Variable Scopes in C

1. Local Variables (Local Variables)

Example of Local Variable Usage

#include <stdio.h>

void myFunction() {
    int localVar = 10;  // local variable
    printf("Local variable: %dn", localVar);
}

int main() {
    myFunction();
    // printf("%d", localVar);  // Error! Local variable cannot be accessed outside the function
    return 0;
}

• Prevents impact between functions (high safety)
• Memory savings (automatically released when the function ends)

• Cannot be accessed from outside the function
• Reinitialized each time the function is called (data is not retained)

2. Global Variables (Global Variables)

Example of Global Variable Usage

#include <stdio.h>

int globalVar = 100;  // global variable

void myFunction() {
    printf("Global variable: %dn", globalVar);
}

int main() {
    myFunction();
    globalVar = 200;  // can be modified from anywhere
    printf("Updated global variable: %dn", globalVar);
    return 0;
}

• Can retain values across the entire program
• Can share data among multiple functions

• Potential for unintended changes (source of bugs)
• Continues to occupy memory
• Makes modularization difficult

3. Static Variables (Static Variables)

Example of static (Retaining Local Variable)

#include <stdio.h>

void counter() {
    static int count = 0;  // static retains value
    count++;
    printf("Count: %dn", count);
}

int main() {
    counter();  // Output: Count: 1
    counter();  // Output: Count: 2
    counter();  // Output: Count: 3
    return 0;
}

• Retains value each time the function is called
• Memory management is simple

• Memory is not released until the program terminates

Example of static (Restricting Global Variable)

static int fileVar = 100;  // valid only within this file

4. External Variables (Extern)

Example of extern

file1.c

#include <stdio.h>

int sharedVar = 50;  // global variable

void printSharedVar() {
    printf("Shared Variable: %dn", sharedVar);
}

file2.c

#include <stdio.h>

extern int sharedVar;  // references variable from file1.c

int main() {
    printf("Accessing sharedVar: %dn", sharedVar);
    return 0;
}

• Other files

• Dependency

5. Variable Lifetime (Lifetime)

Summary

9. Practical Data Type Selection

Why Choosing Data Types Matters

1. When You Want to Save Memory

Integer Memory Sizes and Selection

Memory Saving Example

short temperature;  // Use short to save memory

2. When Accuracy Is Needed

Choosing Floating-Point Types

Example Ensuring Accuracy

double distance = 1234567.1234567;  // When high-precision calculation is needed

3. When Negative Values Are Not Used

Example When Negative Values Are Not Used

unsigned int score = 250;

int x = -1;
unsigned int y = x;  // Causes an error or unintended result

4. Data Types Suitable for Loop Counters

for (unsigned int i = 0; i < 1000; i++) {
    // Loop processing
}

5. When Dealing With Characters

char letter = 'A';   // only one character
char str[] = "Hello";  // string

6. Using Enums to Make Code Clearer

enum Color { RED, GREEN, BLUE };

enum Color favoriteColor = GREEN;

7. Using Pointers for Flexible Memory Management

int num = 10;
int *ptr = #
printf("Value: %dn", *ptr);  // 10

8. Choosing the Optimal Data Type (Summary)

• If you need to save memory, use short or char
• If accuracy is needed, choose double
• If negative values are not needed, use unsigned
• Use enum to improve readability
• Using pointers enables flexible memory management

10. Summary

The Importance of Variables and Data Types in C

1. What is a Variable?

• A variable is a box that stores data and holds values that can be changed within the program.
• Variable declaration and initialization are required, and choosing the appropriate data type is important.

int age = 25;  // integer variable
float pi = 3.14;  // floating-point variable
char letter = 'A';  // character variable

2. Overview of C Data Types

• Basic data types (integer, floating-point, character)
• Derived data types (array, struct, union, enum, pointer)
• By choosing appropriate data types, you can prevent memory waste and make the program more efficient.

3. Basic Data Types (Primitive Types)

4. Derived Data Types (Array, Struct, Union, Enum, Pointer)

• Array → Stores multiple data items of the same type
• Struct (struct) → Manages data of different types as a single unit
• Union (union) → A special data type that shares memory
• Enum (enum) → Defines meaningful constants
• Pointer → Stores memory addresses, enabling flexible data management

5. Type Qualifiers

const int MAX_USERS = 100;  // value cannot be changed

6. Type Conversion (Casting)

int a = 10;
float b = (float)a / 3;  // cast

7. Variable Scope and Lifetime

• Local variable → Valid only within a function
• Global variable → Valid throughout the program (but requires careful management)
• static → Can retain its value, but scope is limited
• extern → Allows a variable to be referenced from other files

static int counter = 0;  // local variable that retains its value

8. Practical Data Type Selection

9. FAQ (Frequently Asked Questions)

Q1. What is the difference between int and long?

long num = 1000000;

Q2. Which should be used, float or double?

double distance = 3.1415926535;

Q3. What changes when using unsigned?

unsigned int positive = 250;

Q4. Can the char type be used as a number?

char letter = 'A';
int ascii = (int)letter;  // 65

Q5. What are the benefits of using const?

const int MAX_VALUE = 100;

Summary

• In C, choosing appropriate data types improves program quality
• By leveraging type qualifiers and casts, you can write safe and efficient programs
• Understanding scope and lifetime enables proper variable management
• Knowing how to choose data types in practice allows for better code design