ארגומנטים משורת הפקודה ב-C: argc, argv וניתוח בטוח

לכל תוכנית שמריצים מטרמינל אפשר להעביר ארגומנטים: gcc -Wall hello.c -o hello מעבירה ארבעה. תוכניות ה-C שלכם קוראות את שלהן דרך שני פרמטרים של main, וזה כל המנגנון: בלי קריאה לספרייה, בלי הכנות.

החתימה

עד עכשיו כל דוגמה בתיעוד הזה השתמשה ב-int main(void). הצורה הסטנדרטית השנייה מקבלת את שורת הפקודה:

int main(int argc, char *argv[]) {
    /* ... */
}

• argc ("argument count") הוא כמה ארגומנטים יש, כולל שם התוכנית.
• argv ("argument vector") הוא מערך של מחרוזות. char *argv[] פירושו "מערך של מצביעים ל-char", כלומר מערך של מחרוזות C.

char **argv הוא כתיב שקול שתראו באותה תדירות; פרמטרים מסוג מערך הופכים למצביעים, כך ששניהם מצהירים על אותו דבר.

#include <stdio.h>

int main(int argc, char *argv[]) {
    printf("argc = %d\n", argc);

    for (int i = 0; i < argc; i++) {
        printf("argv[%d] = \"%s\"\n", i, argv[i]);
    }

    printf("argv[%d] = %s\n", argc, argv[argc] == NULL ? "NULL" : "not null");
    return 0;
}

השתמשו בחלונית Args של העורך כדי לספק ארגומנטים (כל שדה הוא ארגומנט אחד), ואז לחצו Run. נסו שלושה שדות: hello, world, 42.

המבנה

הרצת ./greet Ada Lovelace מפיקה:

ארבע עובדות שכדאי לזכור:

• argc הוא לפחות 1 בפועל, כי argv[0] הוא שם התוכנית. הארגומנטים האמיתיים מתחילים באינדקס 1, ולכן לולאות עליהם מתחילות ב-i = 1.
• הכול הוא מחרוזת. ./prog 42 נותן לכם "42", שני התווים, אף פעם לא את המספר 42. ההמרה היא התפקיד שלכם.
• argv[argc] הוא NULL. התקן מבטיח את זה, כך שאפשר לעבור על המערך בלי argc אם מעדיפים: for (char **p = argv + 1; *p != NULL; p++).
• ה-shell מפצל את המילים, לא התוכנית שלכם. ./prog "Ada Lovelace" הוא ארגומנט אחד; ה-shell צורך את המירכאות והן אף פעם לא מגיעות ל-argv.

בדיקה לפני קריאה

ארגומנט שלא הועבר אינו מחרוזת ריקה: זה זיכרון שאין לכם שום זכות לגעת בו. תמיד בדקו קודם את argc:

#include <stdio.h>

int main(int argc, char *argv[]) {
    if (argc < 2) {
        fprintf(stderr, "usage: %s NAME\n", argv[0]);
        return 1;
    }

    printf("Hello, %s!\n", argv[1]);
    return 0;
}

שתי מוסכמות בתוכנית הזעירה הזו, שתיהן סטנדרטיות בכלי Unix:

• הודעת השימוש הולכת ל-stderr, לא ל-stdout, כדי שלא תזהם פלט שמועבר בצינור למקום אחר.
• ערך החזרה שונה מאפס מ-main מאותת על כישלון למי שהריץ את התוכנית. 0 פירושו הצלחה; כל דבר אחר פירושו שמשהו השתבש. סקריפטים של shell בודקים את זה.

הדפסת argv[0] במקום שם קבוע בקוד פירושה שההודעה תתאים לאופן שבו המשתמש הפעיל את התוכנית, גם אם שמה שונה או שהגיעו אליה בנתיב אחר.

המרת ארגומנטים מספריים

argv[1] הוא טקסט. כדי לעשות חשבון חייבים להמיר אותו, והפונקציה לכך היא strtol מ-<stdlib.h>:

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

/* Returns 1 on success and stores the value; 0 if the text is not a clean integer. */
int parse_int(const char *text, long *out) {
    char *end;
    errno = 0;
    long value = strtol(text, &end, 10);

    if (end == text)        return 0;   /* no digits at all      */
    if (*end != '\0')       return 0;   /* trailing junk: "12abc" */
    if (errno == ERANGE)    return 0;   /* out of long's range    */

    *out = value;
    return 1;
}

int main(int argc, char *argv[]) {
    if (argc < 2) {
        fprintf(stderr, "usage: %s NUMBER...\n", argv[0]);
        return 1;
    }

    long total = 0;
    for (int i = 1; i < argc; i++) {
        long n;
        if (!parse_int(argv[i], &n)) {
            fprintf(stderr, "%s: not an integer: %s\n", argv[0], argv[i]);
            return 1;
        }
        total += n;
    }

    printf("sum = %ld\n", total);
    return 0;
}

הוסיפו 10, 20, 30 כשלושה שדות Args, ואז החליפו אחד מהם ב-banana כדי לראות את מסלול השגיאה.

הפרמטר השלישי של strtol הוא הבסיס: 10 לעשרוני, 16 להקסדצימלי, או 0 לזיהוי אוטומטי לפי קידומת 0x או אפס מוביל. הפרמטר השני הוא המקום שבו נשמר מצביע לתו הראשון שהיא לא צרכה, וזה מה שמאפשר בדיקת שגיאות:

• end == text פירושו שהיא לא ניתחה כלום: הארגומנט לא התחיל במספר.
• *end != '\0' פירושו שנשאר טקסט אחרי המספר, כך ש-"12abc" נדחה במקום להפוך בשקט ל-12.
• errno == ERANGE פירושו שהערך גלש מ-long.

השוו ל-atoi, שקצרה יותר ולא יכולה לדווח על שום דבר מזה:

int n = atoi(argv[1]);   /* "banana" -> 0, "0" -> 0, overflow -> undefined */

atoi מחזירה 0 עבור קלט לא תקין, ואי אפשר להבדיל את זה מאפס אמיתי. השתמשו ב-strtol (וב-strtod עבור נקודה צפה) בכל פעם שהקלט מגיע מחוץ לתוכנית שלכם. עוד בנושא בהמרת מחרוזות.

מחשבון קטן

מחברים הכול יחד: תוכנית שמקבלת מספר, אופרטור ומספר:

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

int parse_double(const char *text, double *out) {
    char *end;
    double v = strtod(text, &end);
    if (end == text || *end != '\0') {
        return 0;
    }
    *out = v;
    return 1;
}

int main(int argc, char *argv[]) {
    if (argc != 4) {
        fprintf(stderr, "usage: %s NUMBER OPERATOR NUMBER\n", argv[0]);
        fprintf(stderr, "  operators: + - x /   (use x, not *, so the shell leaves it alone)\n");
        return 1;
    }

    double a, b;
    if (!parse_double(argv[1], &a) || !parse_double(argv[3], &b)) {
        fprintf(stderr, "%s: both operands must be numbers\n", argv[0]);
        return 1;
    }

    const char *op = argv[2];
    double result;

    if      (strcmp(op, "+") == 0) result = a + b;
    else if (strcmp(op, "-") == 0) result = a - b;
    else if (strcmp(op, "x") == 0) result = a * b;
    else if (strcmp(op, "/") == 0) {
        if (b == 0.0) {
            fprintf(stderr, "%s: division by zero\n", argv[0]);
            return 1;
        }
        result = a / b;
    } else {
        fprintf(stderr, "%s: unknown operator \"%s\"\n", argv[0], op);
        return 1;
    }

    printf("%g\n", result);
    return 0;
}

נסו 12 + 30, אחר כך 7 x 6, ואחר כך 5 / 0.

שימו לב ל-strcmp(op, "+") == 0 במקום op == "+". השוואת ערכי char * עם == משווה כתובות, לא תוכן, והייתה נותנת שקר גם עבור טקסט זהה. ראו פונקציות מחרוזות.

ה-x במקום * הוא פרט מהעולם האמיתי: רוב ה-shells מרחיבים * חשוף לרשימת הקבצים בתיקייה הנוכחית עוד לפני שהתוכנית שלכם רצה. גם עטיפה במירכאות ('*') עובדת, אבל בחירת תו שה-shell מתעלם ממנו ידידותית יותר.

ניתוח דגלים

לפי המוסכמה, אפשרויות מתחילות ב--. לולאה פשוטה שכתובה ביד מטפלת במקרים הנפוצים:

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

int main(int argc, char *argv[]) {
    int verbose = 0;
    long count = 1;
    const char *message = 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], "-n") == 0) {
            if (i + 1 >= argc) {                 /* the value must exist */
                fprintf(stderr, "%s: -n needs a number\n", argv[0]);
                return 1;
            }
            count = strtol(argv[++i], NULL, 10); /* consume the next argument */
        } else if (argv[i][0] == '-') {
            fprintf(stderr, "%s: unknown option %s\n", argv[0], argv[i]);
            return 1;
        } else {
            message = argv[i];
        }
    }

    if (message == NULL) {
        fprintf(stderr, "usage: %s [-v] [-n COUNT] MESSAGE\n", argv[0]);
        return 1;
    }

    if (verbose) {
        printf("printing \"%s\" %ld time(s)\n", message, count);
    }
    for (long i = 0; i < count; i++) {
        printf("%s\n", message);
    }
    return 0;
}

נסו את זה עם ארבעה שדות Args: -v, -n, 3, hello.

הבדיקה i + 1 >= argc לפני argv[++i] היא השורה החשובה: אפשרות שמצפה לערך חייבת לוודא שהערך באמת קיים, אחרת -n כארגומנט האחרון קורא מעבר לסוף המערך. במערכות Unix אמיתיות getopt מ-<unistd.h> עושה את כל זה בשבילכם, כולל אפשרויות קצרות מקובצות כמו -vn3; כדאי לפנות אליה ברגע שלתוכנית יש יותר משניים או שלושה דגלים.

ארגומנטים בעורך שבדפדפן

בלוקי העורך בעמוד הזה מתקמפלים ורצים בשבילכם, וחלונית Args היא המקום שבו מספקים את מה שהיה בא אחרי שם התוכנית בטרמינל. כל שדה שמוסיפים עם Add arg הופך לבדיוק רשומה אחת ב-argv: אין shell באמצע, כך ששום דבר לא מפוצל לפי רווחים ולא צריך מירכאות: שדה שמכיל hello world מגיע כארגומנט יחיד hello world. כדי להעביר -n 3 hello, הוסיפו שלושה שדות. השארת החלונית ריקה נותנת argc == 1, וזו הסיבה שהשומר argc < 2 מופעל בהרצה הראשונה, והסיבה שכדאי לכתוב אותו.

טעויות נפוצות

• קריאת argv[1] בלי לבדוק את argc. התנהגות לא מוגדרת כשלא הועברו ארגומנטים, והקריסה הנפוצה ביותר בתחום הזה.
• התחלת הלולאה ב-i = 0. זה מעבד את שם התוכנית כאילו היה נתון.
• התייחסות ל-argv[1] כמספר. זה טקסט עד שממירים אותו.
• שימוש ב-atoi על קלט משתמש. אין דרך להבדיל בין ארגומנט שגוי לבין אפס.
• השוואת מחרוזות עם ==. השתמשו ב-strcmp.
• כתיבה לתוך המחרוזות של argv. התקן מתיר לשנות אותן, אבל המקום מוגבל ותלוי פלטפורמה; העתיקו לחוצץ משלכם אם צריך לשנות משהו.