Topic 94 of 100 Advanced C Programming Interactive Tutorial

Command-Line Arguments in C: Building Programs That Accept User Input

13 mins read Last updated: 22 Aug 2026 24,100 views

On This Page0 sectionsQuick jump to subtopic

What is Command-Line Arguments in C? Core Concept & Direct Summary

Core Objective & Problem Statement

How do robust command-line programs parse option flags (`-v`, `--output`) and parameters using POSIX `getopt()` or custom parsers?

Direct Answer Summary

In real-world systems, command-line utilities rarely rely on just one mechanism to receive instructions from the outside world. A production tool—such as curl, git, or an embedded configuration daemon—accepts data across three distinct input channels:

Command-Line Arguments (argc, argv): Immediate, non-interactive execution suitable for shell scripting, cron jobs, and CI/CD pipelines.
Environment Variables (getenv): Ambient configuration passed down from the runtime environment or container engine without cluttering process argument lists.
Interactive Prompts (fgets, stdin): Direct communication with a human sitting at a terminal when mandatory arguments are omitted or dangerous confirmations are required.

Programs that mix these channels carelessly end up with subtle bugs: infinite CPU loops when piped input hits End-of-File (EOF), buffer overflows from unsafe input routines (gets, unchecked scanf), or unhandled edge cases where empty strings crash internal parsers.

This comprehensive guide demonstrates how to architect reliable C programs that accept, prioritize, validate, and sanitize user input across all three channels.

How Does Command-Line Arguments in C Work? In-Depth Mechanics & Architecture

The Three Input Channels Compared

Understanding when to accept input via command-line flags versus interactive prompts dictates the ergonomics and scriptability of your application:

Feature / Metric	Command-Line Arguments (`argv`)	Environment Variables (`getenv`)	Interactive Terminal (`stdin`)
Primary Audience	Scripts, CLI power users, CI/CD	Container engines (Docker/K8s), OS sessions	Human operators at a keyboard
Interactivity	Non-blocking / Immediate	Non-blocking / Ambient	Blocking (waits for Enter key or EOF)
Inspection / Safety	Visible via `ps` or `/proc`	Visible within process namespace	Ephemeral in memory buffers
Validation Point	Program initialization (`main`)	Startup initialization	Mid-execution runtime loop
Error Handling	Exit with usage help & code `!= 0`	Fall back to defaults	Re-prompt user until valid

Architecture Diagram

               ┌────────────────────────────────────────────────────────┐               │           INPUT SOURCE PRECEDENCE PIPELINE             │               └────────────────────────────────────────────────────────┘
    [ Hardcoded Defaults ]  ───►  timeout=30, retries=3, port=8080              │              ▼    [ Config File / Env ]   ───►  Overrides unassigned defaults              │              ▼    [ CLI Arguments ]       ───►  Highest precedence (explicit user intent)              │              ▼   Missing Required Values?        ├── NO  ───────────────►  Execute business logic immediately        └── YES ───────────────►  Interactive Mode (-i) Enabled?                                       ├── YES ──► Prompt with validation loops                                       └── NO  ──► Emit error + usage exit(1)

1. Non-Interactive Input: Command-Line Flags (`argc`, `argv`)

Command-line parameters arrive as an array of null-terminated string pointers (char *argv[]). Because all command-line arguments enter your program as raw text, every numerical value requires explicit lexical validation using strtol() or strtod().

The Dangers of `atoi()` and Unchecked `scanf()`

Never use atoi() for command-line parsing or interactive user input:

atoi("foo") silently returns 0, making it impossible to distinguish between the valid number 0 and non-numeric garbage.
atoi() causes undefined behavior on integer overflow.
scanf("%d", ...) leaves unprocessed character noise and newline characters (\n) in the standard input stream buffer, triggering infinite parsing loops on subsequent calls.

Robust Numerical Parsing with `strtol()`

The following function verifies that the entire input string constitutes a valid integer within an explicit range:

main.c

Run Online

#include <stdio.h>
#include <stdlib.h>
#include <errno.h>
int parse_int_safe(const char *str, int min_val, int max_val, int *out_val) {
    if (!str || *str == '\0') {
        return 0;
        /* Reject NULL or empty strings */
    }
    char *endptr = NULL;
    errno = 0;
    long val = strtol(str, &endptr, 10);
    /* Check for range errors (overflow/underflow) */ if (errno != 0) {
        return 0;
    }
    /* Reject if no digits were consumed or if trailing junk exists (e.g. "42abc") */ if (endptr == str || *endptr != '\0') {
        return 0;
    }
    /* Clamp to allowed domain bounds */ if (val < min_val || val > max_val) {
        return 0;
    }
    *out_val =(int)val;
    return 1;
}

2. Ambient Configuration: Environment Variables (`getenv`)

Environment variables supply configuration values without modifying command-line invocations. In standard C (<stdlib.h>), access them using getenv():

Critical Semantics of `getenv()`

Unset vs. Empty: If an environment variable has not been defined in the parent process, getenv() returns NULL. If it was exported with an empty value (export APP_PORT=""), getenv() returns a pointer to an empty string "" (*ptr == '\0'). Always check both conditions!
Read-Only Storage: Never attempt to call free() on or mutate the memory returned by getenv(). The pointer points to operating-system-managed process environment strings. Copy values into local buffers if modification is required.

3. Interactive Input: Safe Prompts, Re-prompting, and EOF Traps

When mandatory arguments are missing or an interactive flag (such as -i or --interactive) is passed, programs request input through standard input (stdin).

The Golden Rule: Read Full Lines with `fgets()`

To prevent buffer overflow attacks, never use the banned gets() function. Instead, use fgets(), which reads up to $N - 1$ characters into a buffer and guarantees null-termination:

The Pitfall of Piped Input and EOF

When users run your program interactively at a terminal keyboard, typing characters followed by Enter submits a newline (\n). However, if a user pipes input into your program (./app < input.txt), the stream eventually reaches End-of-File (EOF).

If your interactive loop assumes input will always arrive and only checks for newline characters:

main.c

Run Online

/* BUGGY CODE: Do not do this! */while (1) {
    fgets(buffer, sizeof(buffer), stdin);
    if (strlen(buffer) > 1) break;
    /* If EOF occurs, fgets returns NULL without modifying buffer! */
}

When fgets() reaches EOF, it returns NULL and leaves the existing memory in buffer unmodified. The loop continues forever, spinning at 100% CPU utilization.

Verified Interactive Validation Loops

A robust interactive input loop must:

Detect NULL return values from fgets(), signaling EOF (Ctrl+D on POSIX, Ctrl+Z on Windows).
Strip trailing \r and \n characters left by carriage returns.
Trim surrounding whitespace.
Reprompt the user upon validation failure without terminating the process.

main.c

Run Online

#include <stdio.h>
#include <string.h>
#include <ctype.h>
/* Helper: strip newline and carriage return characters */static void strip_crlf(char *str) {
    if (!str) return;
    size_t len = strlen(str);
    while (len > 0 &&(str[len - 1] == '\n' || str[len - 1] == '\r')) {
        str[len - 1] = '\0';
        len--;
    }
}
/* Helper: trim leading and trailing whitespace in-place */static char *trim_whitespace(char *str) {
    if (!str) return NULL;
    while (isspace((unsigned char)*str)) str++;
    if (*str == '\0') return str;
    char *end = str + strlen(str) - 1;
    while (end > str && isspace((unsigned char)*end)) end--;
    end[1] = '\0';
    return str;
}
/* Interactive prompt for strings */int prompt_string(const char *prompt, char *buffer, size_t buf_size) {
    char temp[256];
    while (1) {
        printf("%s", prompt);
        fflush(stdout);
        /* Ensure prompt flushes to unbuffered consoles */
        if (!fgets(temp, sizeof(temp), stdin)) {
            printf("\n[EOF encountered: input aborted]\n");
            return 0;
            /* Failure / Stream closed */
        }
        strip_crlf(temp);
        char *trimmed = trim_whitespace(temp);
        if (strlen(trimmed) == 0) {
            printf("Error: input cannot be empty. Please try again.\n");
            continue;
        }
        strncpy(buffer, trimmed, buf_size - 1);
        buffer[buf_size - 1] = '\0';
        return 1;
        /* Success */
    }
}
/* Interactive prompt for bounded integers with optional default fallback */int prompt_int(const char *prompt, int min_val, int max_val, int default_val, int *out_val) {
    char temp[64];
    while (1) {
        if (default_val >= 0) {
            printf("%s [%d]: ", prompt, default_val);
        } else {
            printf("%s (%d-%d): ", prompt, min_val, max_val);
        }
        fflush(stdout);
        if (!fgets(temp, sizeof(temp), stdin)) {
            printf("\n[EOF encountered: input aborted]\n");
            return 0;
        }
        strip_crlf(temp);
        char *trimmed = trim_whitespace(temp);
        /* User pressed Enter without typing; select default if provided */ if (strlen(trimmed) == 0 && default_val >= 0) {
            *out_val = default_val;
            return 1;
        }
        int val = 0;
        if (!parse_int_safe(trimmed, min_val, max_val, &val)) {
            printf("Error: invalid number or out of range (%d to %d). Try again.\n", min_val, max_val);
            continue;
        }
        *out_val = val;
        return 1;
    }
}

4. End-to-End Implementation: Multi-Source Configuration Program

The following production-grade program integrates all three input mechanisms. It models a network utility establishing a connection based on target hostname, port, and retry limit:

Defaults are defined internally.
APP_HOST, APP_PORT, and APP_RETRIES environment variables override defaults.
Command-line flags (-h, -p, -r) override environment variables.
If -i / --interactive is passed or the host remains missing, the application prompts the user interactively with full re-prompt validation loops.

main.c

Run Online

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
#include <errno.h>
#define MAX_NAME_LEN 64
#define DEFAULT_PORT 8080
#define DEFAULT_RETRIES 3
typedef struct {
    char host[MAX_NAME_LEN];
    int port;
    int retries;
    int interactive;
}
AppConfig;
/* Lexical string-to-int converter with bounds enforcement */static int parse_int_safe(const char *str, int min_val, int max_val, int *out_val) {
    if (!str || !*str) return 0;
    char *endptr = NULL;
    errno = 0;
    long val = strtol(str, &endptr, 10);
    if (errno != 0 || endptr == str || *endptr != '\0') return 0;
    if (val < min_val || val > max_val) return 0;
    *out_val =(int)val;
    return 1;
}
static void strip_crlf(char *str) {
    if (!str) return;
    size_t len = strlen(str);
    while (len > 0 &&(str[len - 1] == '\n' || str[len - 1] == '\r')) {
        str[len - 1] = '\0';
        len--;
    }
}
static char *trim_whitespace(char *str) {
    if (!str) return NULL;
    while (isspace((unsigned char)*str)) str++;
    if (*str == '\0') return str;
    char *end = str + strlen(str) - 1;
    while (end > str && isspace((unsigned char)*end)) end--;
    end[1] = '\0';
    return str;
}
static int prompt_string(const char *prompt, char *buffer, size_t buf_size) {
    char temp[256];
    while (1) {
        printf("%s", prompt);
        fflush(stdout);
        if (!fgets(temp, sizeof(temp), stdin)) {
            printf("\n[EOF encountered: input aborted]\n");
            return 0;
        }
        strip_crlf(temp);
        char *trimmed = trim_whitespace(temp);
        if (strlen(trimmed) == 0) {
            printf("Error: input cannot be empty. Please try again.\n");
            continue;
        }
        strncpy(buffer, trimmed, buf_size - 1);
        buffer[buf_size - 1] = '\0';
        return 1;
    }
}
static int prompt_int(const char *prompt, int min_val, int max_val, int default_val, int *out_val) {
    char temp[64];
    while (1) {
        if (default_val >= 0) {
            printf("%s [%d]: ", prompt, default_val);
        } else {
            printf("%s (%d-%d): ", prompt, min_val, max_val);
        }
        fflush(stdout);
        if (!fgets(temp, sizeof(temp), stdin)) {
            printf("\n[EOF encountered: input aborted]\n");
            return 0;
        }
        strip_crlf(temp);
        char *trimmed = trim_whitespace(temp);
        if (strlen(trimmed) == 0 && default_val >= 0) {
            *out_val = default_val;
            return 1;
        }
        int val = 0;
        if (!parse_int_safe(trimmed, min_val, max_val, &val)) {
            printf("Error: invalid number or out of range (%d to %d). Please try again.\n", min_val, max_val);
            continue;
        }
        *out_val = val;
        return 1;
    }
}
static void print_usage(const char *prog_name) {
    printf("Usage: %s [OPTIONS]\n", prog_name);
    printf("Options:\n");
    printf("  -h, --host <hostname>   Target server hostname or IP address\n");
    printf("  -p, --port <port>       Target port (1 - 65535, default: %d)\n", DEFAULT_PORT);
    printf("  -r, --retries <num>     Connection retry count (1 - 10, default: %d)\n", DEFAULT_RETRIES);
    printf("  -i, --interactive       Prompt interactively for missing settings\n");
    printf("  --help                  Display this help message and exit\n");
    printf("\nEnvironment variables:\n");
    printf("  APP_HOST                Fallback target host if -h is not specified\n");
    printf("  APP_PORT                Fallback target port if -p is not specified\n");
    printf("  APP_RETRIES             Fallback retry count if -r is not specified\n");
}
int main(int argc, char *argv[]) {
    AppConfig config;
    memset(&config, 0, sizeof(config));
    config.port = -1;
    /* Sentinel: indicates unassigned */ config.retries = -1;
    /* Sentinel: indicates unassigned */ config.interactive = 0;
    /* Phase 1: Parse Command-Line Arguments */ for (int i = 1; i < argc; i++) {
        if (strcmp(argv[i], "--help") == 0) {
            print_usage(argv[0]);
            return 0;
        } else if (strcmp(argv[i], "-i") == 0 || strcmp(argv[i], "--interactive") == 0) {
            config.interactive = 1;
        } else if (strcmp(argv[i], "-h") == 0 || strcmp(argv[i], "--host") == 0) {
            if (i + 1 >= argc) {
                fprintf(stderr, "Error: %s requires a hostname argument.\n", argv[i]);
                return 1;
            }
            strncpy(config.host, argv[++i], sizeof(config.host) - 1);
            config.host[sizeof(config.host) - 1] = '\0';
        } else if (strcmp(argv[i], "-p") == 0 || strcmp(argv[i], "--port") == 0) {
            if (i + 1 >= argc) {
                fprintf(stderr, "Error: %s requires a port argument.\n", argv[i]);
                return 1;
            }
            if (!parse_int_safe(argv[++i], 1, 65535, &config.port)) {
                fprintf(stderr, "Error: invalid port '%s'. Must be an integer between 1 and 65535.\n", argv[i]);
                return 1;
            }
        } else if (strcmp(argv[i], "-r") == 0 || strcmp(argv[i], "--retries") == 0) {
            if (i + 1 >= argc) {
                fprintf(stderr, "Error: %s requires a retry count argument.\n", argv[i]);
                return 1;
            }
            if (!parse_int_safe(argv[++i], 1, 10, &config.retries)) {
                fprintf(stderr, "Error: invalid retries count '%s'. Must be between 1 and 10.\n", argv[i]);
                return 1;
            }
        } else {
            fprintf(stderr, "Error: unrecognized option '%s'. Run with --help for usage.\n", argv[i]);
            return 1;
        }
    }
    /* Phase 2: Environment Variables Fallback */ if (strlen(config.host) == 0) {
        const char *env_host = getenv("APP_HOST");
        if (env_host && strlen(env_host) > 0) {
            strncpy(config.host, env_host, sizeof(config.host) - 1);
            config.host[sizeof(config.host) - 1] = '\0';
        }
    }
    if (config.port < 0) {
        const char *env_port = getenv("APP_PORT");
        if (env_port) {
            int p = 0;
            if (parse_int_safe(env_port, 1, 65535, &p)) {
                config.port = p;
            } else {
                fprintf(stderr, "Warning: APP_PORT '%s' is invalid, ignoring.\n", env_port);
            }
        }
    }
    if (config.retries < 0) {
        const char *env_retries = getenv("APP_RETRIES");
        if (env_retries) {
            int r = 0;
            if (parse_int_safe(env_retries, 1, 10, &r)) {
                config.retries = r;
            } else {
                fprintf(stderr, "Warning: APP_RETRIES '%s' is invalid, ignoring.\n", env_retries);
            }
        }
    }
    /* Phase 3: Interactive Prompt Fallback */ if (config.interactive) {
        if (strlen(config.host) == 0) {
            if (!prompt_string("Enter target host (e.g., api.example.com): ", config.host, sizeof(config.host))) {
                return 1;
            }
        }
        if (config.port < 0) {
            if (!prompt_int("Enter target port", 1, 65535, DEFAULT_PORT, &config.port)) {
                return 1;
            }
        }
        if (config.retries < 0) {
            if (!prompt_int("Enter retry limit", 1, 10, DEFAULT_RETRIES, &config.retries)) {
                return 1;
            }
        }
    }
    /* Phase 4: Apply Hardcoded Defaults */ if (config.port < 0) config.port = DEFAULT_PORT;
    if (config.retries < 0) config.retries = DEFAULT_RETRIES;
    /* Phase 5: Final Validation Gate */ if (strlen(config.host) == 0) {
        fprintf(stderr, "Error: host was not specified.\n");
        fprintf(stderr, "Provide it via -h/--host, APP_HOST environment variable, or run with -i.\n");
        return 1;
    }
    /* Display Active Configuration */ printf("\n=== Active Program Configuration ===\n");
    printf("Target Host : %s\n", config.host);
    printf("Target Port : %d\n", config.port);
    printf("Retry Limit : %d\n", config.retries);
    printf("Interactive : %s\n", config.interactive ? "Enabled" : "Disabled");
    printf("Status      : Ready to connect.\n");
    return 0;
}

5. Execution Traces Across Multiple Scenarios

Scenario A: Fully Automated Scripting Mode

Supplying all parameters via command line flags bypasses terminal interaction entirely:

main.c

Run Online

$ ./cli_input_demo -h db.internal.net -p 5432 -r 5
=== Active Program Configuration ===Target Host : db.internal.netTarget Port : 5432Retry Limit : 5Interactive : DisabledStatus : Ready to connect.

Scenario B: Environmental Precedence in Containers

Defaults injected via container environment variables are seamlessly adopted without user prompts:

main.c

Run Online

$ export APP_HOST="api.service.local"$ export APP_PORT="9000"$ ./cli_input_demo
=== Active Program Configuration ===Target Host : api.service.localTarget Port : 9000Retry Limit : 3Interactive : DisabledStatus : Ready to connect.

If a command-line flag is added, it wins over the environment variable:

main.c

Run Online

$ ./cli_input_demo -p 443
=== Active Program Configuration ===
Target Host : api.service.local
Target Port : 443
Retry Limit : 3
Interactive : Disabled
Status : Ready to connect.

Scenario C: Interactive Prompts with Input Validation and Re-prompting

Running with -i activates interactive prompting with range validation and graceful default selection:

main.c

Run Online

$ ./cli_input_demo -i
Enter target host(e.g., api.example.com):
Error: input cannot be empty. Please try again.
Enter target host(e.g., api.example.com): gateway.prod.org
Enter target port [8080]: 99999
Error: invalid number or out of range(1 to 65535). Please try again.
Enter target port [8080]:
Enter retry limit [3]: 4
=== Active Program Configuration ===
Target Host : gateway.prod.org
Target Port : 8080
Retry Limit : 4
Interactive : Enabled
Status : Ready to connect.

Notice:

The empty host was rejected with an error message, and the user was re-prompted.
The port 99999 exceeded the valid range ($1$–$65535$) and was rejected.
Pressing Enter at Enter target port [8080]: immediately selected the default port 8080.

6. Common Pitfalls and Anti-Patterns

1. The `fflush(stdout)` Omission

When printing prompts that do not end in a newline character (e.g., printf("Enter port: ");), output buffering may prevent the prompt from displaying on terminal screens before fgets() blocks execution. Always call fflush(stdout) immediately following a prompt.

2. Failure to Strip Newlines

fgets() retains the trailing newline character (\n) if buffer capacity allows. Comparing strings with strcmp(input, "yes") will fail if input actually contains "yes\n". Always strip carriage returns (\r) and newlines (\n) before comparison.

3. Mixing `scanf()` and `fgets()`

Calling scanf("%d", &port) followed by fgets(name, sizeof(name), stdin) is one of the most common C student bugs. scanf consumes numeric digits but leaves the subsequent newline (\n) in stdin. When fgets() runs, it immediately reads the leftover newline and returns an empty string without waiting for the user. Standardize on fgets() for all terminal reading.

4. Memory Overwrite on `strncpy`

strncpy does not guarantee null-termination if the source string exceeds the destination length. Always manually set the final byte to null:

Runnable C Code Example & Practical Implementation

main.c

Run Online

#include <stdio.h>
#include <string.h>
int main(int argc, char *argv[]) {
    int verbose = 0;
    const char *inputFile = NULL;
    for (int i = 1; i < argc; i++) {
        if (strcmp(argv[i], "-v") == 0 || strcmp(argv[i], "--verbose") == 0) {
            verbose = 1;
        } else if (strcmp(argv[i], "-i") == 0 && i + 1 < argc) {
            inputFile = argv[++i];
        }
    }
    printf("CLI Configuration:\
");
    printf("  Verbose Mode: %s\
", verbose ? "ENABLED" : "DISABLED");
    printf("  Input File:   %s\
", inputFile ? inputFile : "(none specified)");
    return 0;
}

Key Takeaways, Best Practices & Memory Safety Rules

Best Practice & Key Takeaways

Always validate that required CLI arguments are present and print clear usage instructions when arguments are missing or malformed.

Frequently Asked Questions & Technical Interview Insights

Technical Interview & Viva Questions

Frequently asked C programming interview questions

Q: What is the advantage of using `getopt()` over manual string parsing for command line options?

A: `getopt()` standardizes POSIX option syntax (flag grouping like `-zxvf`, argument handling, and `--` operand separators) with robust error reporting.

Q: How do you handle unknown command line flags?

A: Print an error message to `stderr`, display usage documentation, and return an exit code such as `EXIT_FAILURE` (1).

Related Tools, Tutorials & Authoritative References

Recommended Interactive Tools

Online C Compiler & Runner — Interactive online GCC sandbox to execute C code in real time.
Online C Code Editor & IDE — Multi-file C programming environment with code formatting.
C++ Programming Tutorial — Transition from procedural C to Object-Oriented C++ with STL.
JavaScript Programming Tutorial — Master modern JavaScript fundamentals, DOM APIs, and async patterns.

Authoritative Standards & Citations

ISO/IEC 9899 (C Language Standard) — Official international C specification by ISO/IEC JTC 1/SC 22/WG 14.
GNU GCC Documentation — Official reference manual for the GNU Compiler Collection and C libraries.
The C Programming Language (K&R) — Definitive classic work by Brian Kernighan & Dennis Ritchie at Bell Labs.
C Reference Documentation (cppreference.com) — Verified reference covering C89 through C23 language features.

Previous TopicThe #include Directive in C: Header Files and Inclusion Methods

Next TopicC Memory Layout: Stack, Heap, Data, Code, and Memory Segments

Command-Line Arguments in C: Building Programs That Accept User Input

What is Command-Line Arguments in C? Core Concept & Direct Summary

How do robust command-line programs parse option flags (`-v`, `--output`) and parameters using POSIX `getopt()` or custom parsers?

How Does Command-Line Arguments in C Work? In-Depth Mechanics & Architecture

The Three Input Channels Compared

1. Non-Interactive Input: Command-Line Flags (argc, argv)

The Dangers of atoi() and Unchecked scanf()

Robust Numerical Parsing with strtol()

2. Ambient Configuration: Environment Variables (getenv)

Critical Semantics of getenv()

3. Interactive Input: Safe Prompts, Re-prompting, and EOF Traps

The Golden Rule: Read Full Lines with fgets()

The Pitfall of Piped Input and EOF

Verified Interactive Validation Loops

4. End-to-End Implementation: Multi-Source Configuration Program

5. Execution Traces Across Multiple Scenarios

Scenario A: Fully Automated Scripting Mode

Scenario B: Environmental Precedence in Containers

Scenario C: Interactive Prompts with Input Validation and Re-prompting

6. Common Pitfalls and Anti-Patterns

1. The fflush(stdout) Omission

2. Failure to Strip Newlines

3. Mixing scanf() and fgets()

4. Memory Overwrite on strncpy

Runnable C Code Example & Practical Implementation

Key Takeaways, Best Practices & Memory Safety Rules

Frequently Asked Questions & Technical Interview Insights

Technical Interview & Viva Questions

Q: What is the advantage of using `getopt()` over manual string parsing for command line options?

Q: How do you handle unknown command line flags?

Related Tools, Tutorials & Authoritative References

Recommended Interactive Tools

Authoritative Standards & Citations

1. Non-Interactive Input: Command-Line Flags (`argc`, `argv`)

The Dangers of `atoi()` and Unchecked `scanf()`

Robust Numerical Parsing with `strtol()`

2. Ambient Configuration: Environment Variables (`getenv`)

Critical Semantics of `getenv()`

The Golden Rule: Read Full Lines with `fgets()`

1. The `fflush(stdout)` Omission

3. Mixing `scanf()` and `fgets()`

4. Memory Overwrite on `strncpy`