C Notes

Hub Applications of C Programming Language Features of C Programming Language History of C Programming Language What is C Language?Why Learn C Programming in 2024?First C Program - Hello World in C with Explanation GCC Compiler - Complete Guide to GNU C Compiler Install C Compiler on Linux - GCC Setup Guide for All Distros Install C Compiler on macOS - Xcode Command Line Tools and Homebrew GCC Install C Compiler on Windows - MinGW, MSYS2, and WSL Guide Setup VS Code for C Programming - Complete Configuration Guide C Syntax Rules — Complete Guide Comments in C Programming Constants in C Programming Data Types in C Identifiers in C Programming Keywords in C Programming Structure of a C Program Variables in C Programming Arithmetic Operators in C Programming Assignment Operators in C Programming Bitwise Operators in C Programming Increment and Decrement Operators in C Logical Operators in C Programming Relational Operators in C Programming Ternary Operator in C Programming Break Statement in C Programming Continue Statement in C Programming Do-While Loop in C Programming For Loop in C Programming Goto Statement in C Programming if-else Statement in C Programming if Statement in C Programming Nested if Statements in C Programming Switch Statement in C Programming While Loop in C Programming Function Arguments in C - Pass by Value vs Pass by Reference Function Call in C Programming Function Declaration (Prototype) in C Function Definition in C Programming Introduction to Functions in C Programming Recursion in C Programming Return Statement in C Programming Storage Classes in C Programming Array Operations in C - Searching, Sorting, Insert and Delete Array Programs in C - Reverse, Rotate, Duplicates, Merge Introduction to Arrays in C Programming Multidimensional Arrays in C Programming One Dimensional Arrays in C Programming Passing Arrays to Functions in C Two Dimensional Arrays in C Programming String Comparison in C - strcmp, strncmp, Case-Insensitive String Functions in C - strlen, strcpy, strcat, strcmp C String Handling Library - Complete string.h Reference String Manipulation in C - Reverse, Uppercase, Palindrome String Programs in C - Anagram, Word Count, Vowels, Frequency Strings in C Programming - Complete Introduction Double Pointers in C - Pointer to Pointer Pointer Arithmetic in C Programming Pointer Declaration and Initialization in C Pointer Programs in C - Swap, String Reversal, Dynamic Allocation Pointers and Arrays in C - The Relationship Explained Pointers and Functions in C - Pass by Reference Introduction to Pointers in C Programming Void Pointers in C - Generic Pointers Guide calloc() in C – Contiguous Memory Allocation Dynamic Arrays in C – Runtime-Sized Arrays free() in C – Releasing Dynamic Memory malloc() in C – Dynamic Memory Allocation Memory Management Best Practices in C realloc() in C – Resizing Dynamic Memory Binary Files in C – fread and fwrite File Handling in C – Introduction File Handling Projects in C – Student Records & Phone Book File Modes in C – Complete Guide fopen() and fclose() in C – Opening and Closing Files Reading Files in C – fgetc, fgets, fscanf, fread Writing Files in C – fputc, fputs, fprintf, fwrite Conditional Compilation in C – #ifdef, #ifndef, #if #define Macros in C – Constants and Macro Functions Header Files in C – Creating Custom Headers #include Directive in C – File Inclusion Macro Functions in C – Parameterized Macros C Preprocessor – Overview and Directives Graphs in C – Adjacency Matrix, Adjacency List, BFS, and DFS Hash Tables in C – Implementation, Collision Handling, and Chaining Linked List in C – Singly, Doubly, and Circular with Implementation Queue in C – Linear, Circular, and Priority Queue Implementation Stack in C – Array and Linked List Implementation with Applications Trees in C – Binary Search Tree Implementation with Traversals C Programming Best Practices – Coding Standards, Safety, and Performance Bit Fields in C – Definition, Use Cases, and Protocol Headers C Standard Library Overview – All Headers and Common Functions Command Line Arguments in C – argc and argv Explained Debugging Techniques in C – GDB, Valgrind, and Sanitizers Function Pointers in C – Complete Guide with Examples Memory Layout of a C Program – Text, Data, BSS, Heap, Stack Bank Management System in C – Complete Project with File Storage File Encryption Tool in C – XOR Cipher Implementation Library Management System in C – Complete Project with Source Code Mini Compiler in C – Lexer and Parser for Simple Expressions Snake Game in C – Console-Based Game with Source Code Student Management System in C – Complete Project with Source Code C Programming Cheatsheet – Complete Quick Reference Guide Top 50 C Programming Interview Questions with Answers (2025)Memory Management Interview Questions in C with Answers Output Prediction Questions in C – What Will This Program Print?Pointer Interview Questions in C – Tricky Problems with Answers Common C Programming Errors and Solutions – Debugging Guide Important C Programs – 50+ Frequently Asked Programs with Solutions Quick Revision Notes for C Programming – Complete C in 10 Minutes Recommended C Programming Books – From Beginner to Expert Format Specifiers in C - Complete Reference getchar() and putchar() in C Programming gets() and puts() in C Programming C Input Output Programs and Examples printf() Function in C Programming scanf() Function in C Programming Arrays of Structures in C – Managing Collections Enums in C – Enumerated Data Types Nested Structures in C – Struct Within Struct Pointers to Structures in C – Arrow Operator Structures in C – User-Defined Data Types typedef in C – Creating Type Aliases Unions in C – Shared Memory Data Types

Storage Classes in C Programming

Complete guide to storage classes in C: auto, register, static, and extern. Understand variable lifetime, scope, linkage, default values, and when to use each storage class with examples.

Storage classes determine four important properties of a variable: its storage location (memory or CPU register), lifetime (how long it exists), scope (where it's accessible), and default initial value. C provides four storage class specifiers: auto, register, static, and extern. Understanding these gives you fine-grained control over variable behavior in your programs.

Overview of Storage Classes

Storage Class	Storage	Lifetime	Scope	Default Value
`auto`	Stack (RAM)	Until function returns	Local to block	Garbage
`register`	CPU Register (suggestion)	Until function returns	Local to block	Garbage
`static` (local)	Data segment (RAM)	Entire program	Local to block	0
`static` (global)	Data segment (RAM)	Entire program	File only	0
`extern`	Data segment (RAM)	Entire program	Global (multi-file)	0

auto — Automatic Storage Class

auto is the default storage class for all local variables. You rarely see it written explicitly because it's implied for any variable declared inside a function or block.

c example

#include <stdio.h>

void demonstrate() {
    auto int x = 10;  // Explicitly auto (unnecessary)
    int y = 20;       // Implicitly auto (same thing)

    printf("x = %d, y = %d\n", x, y);
}
// x and y are DESTROYED when demonstrate() returns

int main() {
    demonstrate();
    demonstrate();  // x and y are re-created each call

    // Uninitialized auto variable has garbage value
    int uninit;
    printf("Uninitialized auto: %d (garbage!)\n", uninit);

    return 0;
}

Output

x = 10, y = 20
x = 10, y = 20
Uninitialized auto: 32767 (garbage!)

Key characteristics of auto:

Stored on the stack
Created when the block is entered, destroyed when it exits
Must be explicitly initialized (contains garbage otherwise)
Cannot be accessed outside its scope
The auto keyword is almost never written in practice

register — Register Storage Class

The register keyword is a hint to the compiler to store the variable in a CPU register instead of RAM for faster access. Modern compilers are smart enough to make this optimization themselves, so register is largely obsolete.

Example

#include <stdio.h> int main() { register int i; // Suggest storing in register int sum = 0; // Useful for loop counters that are accessed frequently for (i = 1; i <= 1000000; i++) { sum += i; } printf("Sum 1 to 1000000 = %d\n", sum); // IMPORTANT: Can't take address of register variable // printf("%p", &i); // ERROR! No address for register variable return 0; }

Output

Sum 1 to 1000000 = 1784293664

Key characteristics of register:

Only a suggestion — compiler may ignore it
Cannot use & (address-of) operator on register variables
Limited to block scope (like auto)
Best for frequently accessed variables (loop counters)
Modern compilers optimize this automatically, making the keyword unnecessary

static — Static Storage Class

The static keyword is the most useful and interesting storage class. It has different effects depending on where it's used:

Static Local Variables

A static local variable retains its value between function calls — it's initialized only once and persists for the program's entire lifetime:

Example

#include <stdio.h> void counter() { static int count = 0; // Initialized ONLY on first call count++; printf("Called %d time(s)\n", count); } void autoCounter() { int count = 0; // Re-initialized every call count++; printf("Auto count: %d (always 1)\n", count); } int main() { counter(); // count = 1 counter(); // count = 2 counter(); // count = 3 printf("\n"); autoCounter(); // count = 1 autoCounter(); // count = 1 autoCounter(); // count = 1 return 0; }

Output

Called 1 time(s)
Called 2 time(s)
Called 3 time(s)

Auto count: 1 (always 1)
Auto count: 1 (always 1)
Auto count: 1 (always 1)

Practical Uses of Static Local Variables

Example

#include <stdio.h> // Generate unique IDs int getNextID() { static int id = 100; return ++id; } // Track function statistics float runningAverage(float newValue) { static float total = 0; static int count = 0; total += newValue; count++; return total / count; } // Fibonacci with memoization (simple approach) int fibMemo(int n) { static int cache[50] = {0}; static int initialized = 0; if (!initialized) { cache[0] = 0; cache[1] = 1; initialized = 1; } if (n <= 1) return cache[n]; if (cache[n] != 0) return cache[n]; cache[n] = fibMemo(n - 1) + fibMemo(n - 2); return cache[n]; } int main() { printf("IDs: %d, %d, %d\n", getNextID(), getNextID(), getNextID()); printf("Avg after 10: %.1f\n", runningAverage(10)); printf("Avg after 20: %.1f\n", runningAverage(20)); printf("Avg after 30: %.1f\n", runningAverage(30)); printf("Fib(10) = %d\n", fibMemo(10)); printf("Fib(20) = %d\n", fibMemo(20)); return 0; }

Output

IDs: 101, 102, 103
Avg after 10: 10.0
Avg after 20: 15.0
Avg after 30: 20.0
Fib(10) = 55
Fib(20) = 6765

Static Global Variables and Functions

When static is applied to a global variable or function, it limits visibility to that file only (internal linkage):

c example

// file1.c
#include <stdio.h>

// This variable can only be used within file1.c
static int fileLocalVar = 42;

// This function can only be called from within file1.c
static void helperFunction() {
    printf("I'm a private helper: %d\n", fileLocalVar);
}

void publicFunction() {
    helperFunction();  // Can call from same file
    printf("I'm accessible from other files\n");
}

c example

// file2.c
extern void publicFunction();  // OK - visible
// extern int fileLocalVar;    // ERROR - static, not visible!
// extern void helperFunction(); // ERROR - static, not visible!

int main() {
    publicFunction();  // Works
    return 0;
}

extern — External Storage Class

The extern keyword declares that a variable is defined in another file or elsewhere in the program. It doesn't allocate memory — it just tells the compiler "this variable exists somewhere else."

c example

// globals.c - Definition (allocates memory)
int sharedCounter = 0;
float pi = 3.14159;

Example

// main.c - Declaration (uses extern, no memory allocated) #include <stdio.h> extern int sharedCounter; // Defined in globals.c extern float pi; // Defined in globals.c void incrementCounter() { sharedCounter++; } int main() { printf("Counter: %d\n", sharedCounter); incrementCounter(); incrementCounter(); printf("Counter: %d\n", sharedCounter); printf("Pi: %f\n", pi); return 0; }

Output

Counter: 0
Counter: 2
Pi: 3.141590

extern with Functions

Function declarations are implicitly extern — you can use functions defined in other files without explicitly writing extern:

c example

// math_utils.c
int add(int a, int b) {
    return a + b;
}

c example

// main.c
#include <stdio.h>

// Both are equivalent:
extern int add(int a, int b);  // Explicit extern
// int add(int a, int b);      // Implicit extern (same thing)

int main() {
    printf("3 + 4 = %d\n", add(3, 4));
    return 0;
}

Comparison Example

Example

#include <stdio.h> int globalVar = 100; // Global: lifetime = entire program, scope = all files void demoStorage() { auto int autoVar = 1; // Created & destroyed each call static int staticVar = 1; // Persists between calls register int regVar = 1; // Suggests register storage printf("auto=%d, static=%d, register=%d, global=%d\n", autoVar, staticVar, regVar, globalVar); autoVar++; staticVar++; regVar++; globalVar++; } int main() { printf("Call 1: "); demoStorage(); printf("Call 2: "); demoStorage(); printf("Call 3: "); demoStorage(); return 0; }

Output

Call 1: auto=1, static=1, register=1, global=100
Call 2: auto=1, static=2, register=1, global=101
Call 3: auto=1, static=3, register=1, global=102

Notice:

autoVar and regVar are always 1 (recreated each call)
staticVar increments across calls (persists)
globalVar also persists and increments

Default Initial Values

c example

#include <stdio.h>

int globalInt;       // Default: 0
float globalFloat;   // Default: 0.0
char globalChar;     // Default: '\0'
int *globalPtr;      // Default: NULL

int main() {
    static int staticInt;   // Default: 0
    static float staticF;   // Default: 0.0

    int autoInt;           // Default: GARBAGE!
    float autoFloat;       // Default: GARBAGE!

    printf("Global int: %d\n", globalInt);
    printf("Global float: %f\n", globalFloat);
    printf("Global ptr: %p\n", (void*)globalPtr);
    printf("Static int: %d\n", staticInt);
    printf("Auto int: %d (garbage!)\n", autoInt);

    return 0;
}

Output

Global int: 0
Global float: 0.000000
Global ptr: (nil)
Static int: 0
Auto int: 32651 (garbage!)

When to Use Each Storage Class

Scenario	Use
Normal local variables	`auto` (default, don't write it)
Value must persist between calls	`static` local
Limit global visibility to one file	`static` global
Share variables across files	`extern`
Performance-critical loop counter	`register` (usually unnecessary)

Interview Questions

Q1: What is the difference between a static local variable and a global variable?

Both persist for the program's entire lifetime and are initialized to 0 by default. The difference is scope: a static local variable is only accessible within its function, providing encapsulation. A global variable is accessible from any function in the file (or other files with extern), which can lead to naming conflicts and uncontrolled access.

Q2: What does static mean for a function in C?

When applied to a function, static gives it internal linkage — the function can only be called from within the same source file. It's essentially a "private" function, hidden from other files. This is useful for helper functions that shouldn't be part of a module's public API.

Q3: What is the difference between declaration and definition with extern?

extern int x; is a declaration — it tells the compiler "x exists somewhere" without allocating memory. int x = 5; (or just int x; at file scope) is a definition — it allocates memory and optionally initializes the variable. A variable can be declared many times but defined only once.

Q4: Why can't you take the address of a register variable?

CPU registers don't have memory addresses — they're not part of RAM. Since register suggests storing the variable in a register (not memory), taking its address with & is not allowed. The compiler enforces this even if it decides to keep the variable in memory.

Q5: What happens to a static variable when the function is called recursively?

There's only ONE instance of a static variable regardless of how many recursive calls are active. All recursive invocations share the same static variable. This contrasts with auto variables, where each recursive call gets its own independent copy on the stack.

Summary

auto is the default for locals: stack storage, block scope, garbage initial value
register suggests register storage for speed, but compilers usually ignore it
static local variables persist between function calls and are initialized to 0
static global variables/functions are restricted to their file (internal linkage)
extern declares a variable defined elsewhere (no memory allocation)
Global and static variables default to 0; auto variables contain garbage
Use static for persistent state and extern for cross-file variable sharing

Exam Focus

Revise definitions, diagrams, examples, and short-answer points for Storage Classes in C Programming.

Interview Use

Prepare one clear explanation, one practical example, and one common mistake for this C Programming topic.

Search Terms

c-programming, c programming, programming, functions, storage, classes, storage classes in c programming

Continue learning this concept

FunctionsFunction Arguments in C - Pass by Value vs Pass by ReferenceUnderstand how arguments are passed to functions in C: pass by value vs pass by reference (using pointers). Learn when to use each approach with practical examples and common patterns.FunctionsFunction Call in C ProgrammingLearn how to call functions in C: passing arguments, receiving return values, actual vs formal parameters, nested function calls, and the function call mechanism with stack frames.FunctionsFunction Declaration (Prototype) in CLearn function declarations and prototypes in C programming. Understand why prototypes are needed, syntax rules, implicit declarations, and best practices for declaring functions before use.FunctionsFunction Definition in C ProgrammingLearn how to define functions in C: syntax, return types, parameters, function body, local variables, and the complete anatomy of a function definition with practical examples.FunctionsIntroduction to Functions in C ProgrammingLearn what functions are in C, why they FunctionsRecursion in C ProgrammingMaster recursion in C: base cases, recursive cases, stack frames, factorial, Fibonacci, tower of Hanoi, and more. Understand when recursion beats iteration and common pitfalls.

PreviousReturn Statement in C Programming NextArray Operations in C - Searching, Sorting, Insert and Delete

C Notes

Storage Classes in C Programming

Complete guide to storage classes in C: auto, register, static, and extern. Understand variable lifetime, scope, linkage, default values, and when to use each storage class with examples.

Overview of Storage Classes

Storage Class	Storage	Lifetime	Scope	Default Value
`auto`	Stack (RAM)	Until function returns	Local to block	Garbage
`register`	CPU Register (suggestion)	Until function returns	Local to block	Garbage
`static` (local)	Data segment (RAM)	Entire program	Local to block	0
`static` (global)	Data segment (RAM)	Entire program	File only	0
`extern`	Data segment (RAM)	Entire program	Global (multi-file)	0

auto — Automatic Storage Class

auto is the default storage class for all local variables. You rarely see it written explicitly because it's implied for any variable declared inside a function or block.

c example

#include <stdio.h>

void demonstrate() {
    auto int x = 10;  // Explicitly auto (unnecessary)
    int y = 20;       // Implicitly auto (same thing)

    printf("x = %d, y = %d\n", x, y);
}
// x and y are DESTROYED when demonstrate() returns

int main() {
    demonstrate();
    demonstrate();  // x and y are re-created each call

    // Uninitialized auto variable has garbage value
    int uninit;
    printf("Uninitialized auto: %d (garbage!)\n", uninit);

    return 0;
}

Output

x = 10, y = 20
x = 10, y = 20
Uninitialized auto: 32767 (garbage!)

Key characteristics of auto:

Stored on the stack
Created when the block is entered, destroyed when it exits
Must be explicitly initialized (contains garbage otherwise)
Cannot be accessed outside its scope
The auto keyword is almost never written in practice

register — Register Storage Class

Example

Output

Sum 1 to 1000000 = 1784293664

Key characteristics of register:

Only a suggestion — compiler may ignore it
Cannot use & (address-of) operator on register variables
Limited to block scope (like auto)
Best for frequently accessed variables (loop counters)
Modern compilers optimize this automatically, making the keyword unnecessary

static — Static Storage Class

The static keyword is the most useful and interesting storage class. It has different effects depending on where it's used:

Static Local Variables

A static local variable retains its value between function calls — it's initialized only once and persists for the program's entire lifetime:

Example

Output

Called 1 time(s)
Called 2 time(s)
Called 3 time(s)

Auto count: 1 (always 1)
Auto count: 1 (always 1)
Auto count: 1 (always 1)

Practical Uses of Static Local Variables

Example

Output

IDs: 101, 102, 103
Avg after 10: 10.0
Avg after 20: 15.0
Avg after 30: 20.0
Fib(10) = 55
Fib(20) = 6765

Static Global Variables and Functions

When static is applied to a global variable or function, it limits visibility to that file only (internal linkage):

c example

// file1.c
#include <stdio.h>

// This variable can only be used within file1.c
static int fileLocalVar = 42;

// This function can only be called from within file1.c
static void helperFunction() {
    printf("I'm a private helper: %d\n", fileLocalVar);
}

void publicFunction() {
    helperFunction();  // Can call from same file
    printf("I'm accessible from other files\n");
}

c example

// file2.c
extern void publicFunction();  // OK - visible
// extern int fileLocalVar;    // ERROR - static, not visible!
// extern void helperFunction(); // ERROR - static, not visible!

int main() {
    publicFunction();  // Works
    return 0;
}

extern — External Storage Class

The extern keyword declares that a variable is defined in another file or elsewhere in the program. It doesn't allocate memory — it just tells the compiler "this variable exists somewhere else."

c example

// globals.c - Definition (allocates memory)
int sharedCounter = 0;
float pi = 3.14159;

Example

Output

Counter: 0
Counter: 2
Pi: 3.141590

extern with Functions

Function declarations are implicitly extern — you can use functions defined in other files without explicitly writing extern:

c example

// math_utils.c
int add(int a, int b) {
    return a + b;
}

c example

// main.c
#include <stdio.h>

// Both are equivalent:
extern int add(int a, int b);  // Explicit extern
// int add(int a, int b);      // Implicit extern (same thing)

int main() {
    printf("3 + 4 = %d\n", add(3, 4));
    return 0;
}

Comparison Example

Example

Output

Call 1: auto=1, static=1, register=1, global=100
Call 2: auto=1, static=2, register=1, global=101
Call 3: auto=1, static=3, register=1, global=102

Notice:

autoVar and regVar are always 1 (recreated each call)
staticVar increments across calls (persists)
globalVar also persists and increments

Default Initial Values

c example

#include <stdio.h>

int globalInt;       // Default: 0
float globalFloat;   // Default: 0.0
char globalChar;     // Default: '\0'
int *globalPtr;      // Default: NULL

int main() {
    static int staticInt;   // Default: 0
    static float staticF;   // Default: 0.0

    int autoInt;           // Default: GARBAGE!
    float autoFloat;       // Default: GARBAGE!

    printf("Global int: %d\n", globalInt);
    printf("Global float: %f\n", globalFloat);
    printf("Global ptr: %p\n", (void*)globalPtr);
    printf("Static int: %d\n", staticInt);
    printf("Auto int: %d (garbage!)\n", autoInt);

    return 0;
}

Output

Global int: 0
Global float: 0.000000
Global ptr: (nil)
Static int: 0
Auto int: 32651 (garbage!)

When to Use Each Storage Class

Scenario	Use
Normal local variables	`auto` (default, don't write it)
Value must persist between calls	`static` local
Limit global visibility to one file	`static` global
Share variables across files	`extern`
Performance-critical loop counter	`register` (usually unnecessary)

Interview Questions

Q1: What is the difference between a static local variable and a global variable?

Q2: What does static mean for a function in C?

Q3: What is the difference between declaration and definition with extern?

Q4: Why can't you take the address of a register variable?

Q5: What happens to a static variable when the function is called recursively?

Summary

auto is the default for locals: stack storage, block scope, garbage initial value
register suggests register storage for speed, but compilers usually ignore it
static local variables persist between function calls and are initialized to 0
static global variables/functions are restricted to their file (internal linkage)
extern declares a variable defined elsewhere (no memory allocation)
Global and static variables default to 0; auto variables contain garbage
Use static for persistent state and extern for cross-file variable sharing

Exam Focus

Revise definitions, diagrams, examples, and short-answer points for Storage Classes in C Programming.

Interview Use

Prepare one clear explanation, one practical example, and one common mistake for this C Programming topic.

Search Terms

c-programming, c programming, programming, functions, storage, classes, storage classes in c programming

Continue learning this concept

PreviousReturn Statement in C Programming NextArray Operations in C - Searching, Sorting, Insert and Delete

Overview of Storage Classes

auto — Automatic Storage Class

register — Register Storage Class

static — Static Storage Class

Static Local Variables

Practical Uses of Static Local Variables

Static Global Variables and Functions

extern — External Storage Class

Sharing Variables Between Files

extern with Functions

Comparison Example

Default Initial Values

When to Use Each Storage Class

Interview Questions

Summary

Continue learning this concept

Overview of Storage Classes

auto — Automatic Storage Class

register — Register Storage Class

static — Static Storage Class

Static Local Variables

Practical Uses of Static Local Variables

Static Global Variables and Functions

extern — External Storage Class

Sharing Variables Between Files

extern with Functions

Comparison Example

Default Initial Values

When to Use Each Storage Class

Interview Questions

Summary

Continue learning this concept