Advanced Library Functions

🎭 The Emergency Exit & Magic Box Guide

Advanced Library Functions in C: Program Termination & Variable Arguments

🌟 The Story Begins…

Imagine you’re in a giant building (your C program). Sometimes you need to:

1. Leave the building quickly through emergency exits (Program Termination)
2. Open a magic gift box that can hold ANY number of presents (Variable Arguments)

Let’s explore both!

🚪 Part 1: Program Termination Functions

The Emergency Exit System

Think of your program like a movie theater. When the movie ends (or there’s an emergency), you need ways to leave!

🎬 The exit() Function - The Normal Exit Door

exit() is like walking out through the main door after the movie ends. You tell everyone “I’m leaving!” and everything gets cleaned up.

#include <stdlib.h>

int main() {
    printf("Movie starting!\n");

    // Oops, something went wrong
    if (problem_found) {
        exit(1);  // Leave with code 1 (error)
    }

    exit(0);  // Leave with code 0 (success)
}

🎯 Exit Codes Explained

🧹 What Happens When You exit()?

1. ✅ All open files get closed nicely
2. ✅ All temporary files get deleted
3. ✅ Special “cleanup” functions run (called atexit handlers)
4. ✅ Buffers get flushed (data gets saved)

⚡ The _Exit() Function - The Emergency Fire Exit

_Exit() is the fire escape door. You run out IMMEDIATELY! No time to grab your popcorn or jacket.

#include <stdlib.h>

int main() {
    printf("EMERGENCY! ");
    _Exit(1);  // RUN! No cleanup!

    // This line NEVER runs
    printf("Bye!");
}

🆚 exit() vs _Exit() - The Big Difference

graph TD
    A["Program Ends"] --> B{Which exit?}
    B -->|exit| C["📋 Run cleanup handlers"]
    C --> D["📁 Flush and close files"]
    D --> E["👋 Goodbye properly"]
    B -->|_Exit| F["🏃 Leave IMMEDIATELY"]
    F --> G["❌ Skip everything"]

🎪 The atexit() Function - The Cleanup Crew

atexit() lets you schedule cleanup tasks that run when you leave. Like telling janitors “When I leave, please clean these specific things!”

#include <stdlib.h>
#include <stdio.h>

void say_goodbye() {
    printf("Bye bye! 👋\n");
}

void close_database() {
    printf("Database closed! 💾\n");
}

int main() {
    // Register cleanup functions
    atexit(say_goodbye);
    atexit(close_database);

    printf("Program running...\n");

    exit(0);  // Now cleanup runs!
}

📤 Output:

Program running...
Database closed! 💾
Bye bye! 👋

🔄 Important: LIFO Order (Last In, First Out)

Functions run in reverse order! Like a stack of plates:

• Last registered = First to run
• First registered = Last to run

💣 The abort() Function - The Panic Button

abort() is like pulling the fire alarm. Everything stops IMMEDIATELY with a loud crash!

#include <stdlib.h>

int main() {
    int data = get_critical_data();

    if (data < 0) {
        printf("CRITICAL ERROR! ");
        abort();  // CRASH! Core dump created
    }

    return 0;
}

⚠️ When to Use abort()?

• 🚨 Impossible situations that should NEVER happen
• 🔍 Debugging - when you need a crash report
• 💔 Corrupted data that can’t be recovered

🔄 The quick_exit() & at_quick_exit() Combo

These are like a side door with its own cleanup crew.

#include <stdlib.h>

void quick_cleanup() {
    printf("Quick cleanup done!\n");
}

int main() {
    at_quick_exit(quick_cleanup);

    // Later...
    quick_exit(0);  // Uses quick_exit handlers
}

🎯 Summary Table: All Exit Functions

📦 Part 2: Variable Argument Functions

The Magic Gift Box That Holds Anything

🎁 What Are Variable Arguments?

Imagine a magic box that can hold 1 gift, 3 gifts, or 100 gifts! You don’t decide the size when making the box.

That’s what variable arguments do in C!

printf("Hello");           // 1 argument
printf("I am %d", 10);     // 2 arguments
printf("%s is %d", "Age", 25);  // 3 arguments

printf takes ANY number of arguments. How? Magic! (Actually, va_list!)

🧙‍♂️ The Four Magic Spells (Macros)

To create your own “magic box” function, you need 4 spells from <stdarg.h>:

graph TD
    A["va_list"] -->|1. Create the box| B["va_start"]
    B -->|2. Open the box| C["va_arg"]
    C -->|3. Take gifts out| D["va_end"]
    D -->|4. Close the box| E["Done!"]

📝 Creating Your First Magic Function

Let’s make a function that adds any amount of numbers!

#include <stdio.h>
#include <stdarg.h>

int add_all(int count, ...) {
    va_list args;      // 1. Magic box
    va_start(args, count);  // 2. Open it

    int sum = 0;
    for (int i = 0; i < count; i++) {
        sum += va_arg(args, int);  // 3. Take
    }

    va_end(args);      // 4. Close it
    return sum;
}

int main() {
    printf("%d\n", add_all(3, 10, 20, 30));
    printf("%d\n", add_all(5, 1, 2, 3, 4, 5));
    return 0;
}

📤 Output:

60
15

🔍 Understanding Each Magic Spell

1️⃣ va_list - The Magic Box

va_list args;  // Declares a magic box

Think: “I’m getting a box ready to hold mystery gifts!”

2️⃣ va_start - Opening the Box

va_start(args, last_fixed_param);

• args = your magic box
• last_fixed_param = the last “normal” parameter before ...

int my_func(int count, const char *name, ...) {
    va_list args;
    va_start(args, name);  // 'name' is last before ...
}

3️⃣ va_arg - Taking Gifts Out

int x = va_arg(args, int);     // Take an int
double y = va_arg(args, double);  // Take a double
char *s = va_arg(args, char*);    // Take a string

⚠️ You MUST know the type! The box doesn’t label the gifts!

4️⃣ va_end - Closing the Box

va_end(args);  // Always clean up!

Like closing a door when you leave. It’s polite AND necessary!

🌈 Real Example: Custom Print Function

#include <stdio.h>
#include <stdarg.h>

void my_print(const char *format, ...) {
    va_list args;
    va_start(args, format);

    while (*format) {
        if (*format == '%') {
            format++;
            if (*format == 'd') {
                printf("%d", va_arg(args, int));
            } else if (*format == 's') {
                printf("%s", va_arg(args, char*));
            }
        } else {
            putchar(*format);
        }
        format++;
    }

    va_end(args);
}

int main() {
    my_print("Name: %s, Age: %d\n", "Ali", 12);
    return 0;
}

📤 Output:

Name: Ali, Age: 12

📋 va_copy - Cloning the Magic Box

Sometimes you need a backup of your box!

va_list args, args_copy;
va_start(args, count);
va_copy(args_copy, args);  // Make a clone!

// Use args...
// Later use args_copy...

va_end(args);
va_end(args_copy);  // Must close both!

⚠️ Common Mistakes to Avoid

❌ Wrong Type!

// If caller passes an int...
double x = va_arg(args, double);  // 💥 CRASH!

❌ Forgetting va_end

va_start(args, count);
// ... use args ...
// Forgot va_end(args); 💥 Memory leak!

❌ Using Args After va_end

va_end(args);
int x = va_arg(args, int);  // 💥 Undefined!

🎯 Quick Reference Chart

graph LR
    A["Step 1<br>va_list args"] --> B["Step 2<br>va_start"]
    B --> C["Step 3<br>va_arg loop"]
    C --> D["Step 4<br>va_end"]
    style A fill:#e3f2fd
    style B fill:#c8e6c9
    style C fill:#fff9c4
    style D fill:#ffcdd2

🏆 Putting It All Together

Here’s a complete example combining both concepts!

#include <stdio.h>
#include <stdlib.h>
#include <stdarg.h>

void cleanup() {
    printf("Cleanup complete!\n");
}

void log_error(const char *fmt, ...) {
    va_list args;
    va_start(args, fmt);

    printf("[ERROR] ");
    vprintf(fmt, args);  // Special printf!
    printf("\n");

    va_end(args);
}

int main() {
    atexit(cleanup);

    int code = 404;
    log_error("File not found: %s (code %d)",
              "data.txt", code);

    exit(EXIT_FAILURE);
}

📤 Output:

[ERROR] File not found: data.txt (code 404)
Cleanup complete!

🎉 You Did It!

You now understand:

• 🚪 How to exit programs gracefully (or not!)
• 📦 How to create functions with flexible arguments
• 🧹 How to set up cleanup routines
• 🧙‍♂️ The magic of va_list and friends

Remember:

• exit() = Polite goodbye
• abort() = Emergency escape
• va_list = Magic box for any number of arguments

Happy coding! 🚀