Befehlszeilenargumente in C parsen

Einführung

In diesem Lab erfahren Sie, wie Sie Befehlszeilenargumente in der C-Programmierung analysieren (parsen) können. Das Lab behandelt die grundlegenden Konzepte von Befehlszeilenargumenten, einschließlich des Zugriffs auf die Anzahl der Argumente, des Abrufs von Argumentwerten, der Behandlung ungültiger Argumente und der Implementierung eines einfachen Befehlszeilentools. Am Ende des Labs werden Sie ein solides Verständnis davon haben, wie Sie in Ihren C-Programmen mit Befehlszeilenargumenten arbeiten können.

Skills Graph

Befehlszeilenargumente verstehen

In diesem Schritt lernen Sie die grundlegenden Konzepte von Befehlszeilenargumenten in der C-Programmierung und wie diese an ein Programm übergeben werden, wenn es ausgeführt wird.

Was sind Befehlszeilenargumente?

Befehlszeilenargumente sind Parameter, die an ein Programm übergeben werden, wenn es von der Befehlszeile aus gestartet wird. In C werden diese Argumente von der main()-Funktion über zwei spezielle Parameter empfangen: argc und argv.

1. Erstellen Sie eine neue Datei namens arguments_intro.c im Verzeichnis ~/project:

cd ~/project
touch arguments_intro.c

2. Fügen Sie den folgenden Code hinzu, um Befehlszeilenargumente zu untersuchen:

#include <stdio.h>

int main(int argc, char* argv[]) {
    printf("Number of arguments: %d\n", argc);

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

    return 0;
}

3. Kompilieren Sie das Programm:

gcc arguments_intro.c -o arguments_intro

4. Führen Sie das Programm mit unterschiedlicher Anzahl von Argumenten aus:

./arguments_intro
./arguments_intro Hello
./arguments_intro Hello World

Beispielausgabe:

## When no arguments are provided
Number of arguments: 1
Argument 0:./arguments_intro

## With one argument
Number of arguments: 2
Argument 0:./arguments_intro
Argument 1: Hello

## With two arguments
Number of arguments: 3
Argument 0:./arguments_intro
Argument 1: Hello
Argument 2: World

argc und argv verstehen

• argc (Anzahl der Argumente): Repräsentiert die Gesamtzahl der an das Programm übergebenen Argumente, einschließlich des Programmnamens selbst.
• argv (Argumentvektor): Ein Array von Zeichenketten, das die eigentlichen Argumente enthält.
• argv[0] ist immer der Name des Programms.
• Die folgenden Argumente beginnen bei argv[1].

Zugriff auf die Anzahl der Argumente

In diesem Schritt erfahren Sie, wie Sie die Anzahl der an ein C-Programm übergebenen Argumente mithilfe des argc-Parameters zugreifen und nutzen können.

Prüfen der Anzahl der Argumente

Das Verständnis, wie man die Anzahl der Argumente prüft, ist entscheidend für die Erstellung flexibler und robuster Befehlszeilenprogramme. Sie lernen, wie Sie die Anzahl der Argumente validieren und passende Rückmeldungen geben können.

1. Erstellen Sie eine neue Datei namens argument_count.c im Verzeichnis ~/project:

cd ~/project
touch argument_count.c

2. Fügen Sie den folgenden Code hinzu, um die Prüfung der Argumentanzahl zu demonstrieren:

#include <stdio.h>

int main(int argc, char* argv[]) {
    // Check if the correct number of arguments is provided
    if (argc < 2) {
        printf("Error: At least one argument is required.\n");
        printf("Usage: %s <argument1> [argument2]...\n", argv[0]);
        return 1;
    }

    // Print the total number of arguments
    printf("Total number of arguments: %d\n", argc);

    // Check for a maximum number of arguments
    if (argc > 4) {
        printf("Warning: Too many arguments. Only first 3 will be processed.\n");
    }

    return 0;
}

3. Kompilieren Sie das Programm:

gcc argument_count.c -o argument_count

4. Führen Sie das Programm mit unterschiedlicher Anzahl von Argumenten aus:

## No arguments
./argument_count

## One argument
./argument_count Hello

## Multiple arguments
./argument_count Hello World Lab

## Too many arguments
./argument_count Arg1 Arg2 Arg3 Arg4 Arg5

Beispielausgabe:

## No arguments
Error: At least one argument is required.
Usage:./argument_count <argument1> [argument2]...

## One argument
Total number of arguments: 2

## Multiple arguments
Total number of arguments: 4

## Too many arguments
Total number of arguments: 6
Warning: Too many arguments. Only first 3 will be processed.

Wichtige Konzepte

• argc gibt Ihnen die Gesamtzahl der Argumente an, einschließlich des Programmnamens.
• Sie können argc verwenden, um die Anzahl der Argumente zu validieren.
• Geben Sie klare Nutzungsanweisungen, wenn falsche Argumente angegeben werden.
• Behandeln Sie Fälle mit zu wenigen oder zu vielen Argumenten elegant.

Abrufen von Argumentwerten

In diesem Schritt lernen Sie, wie Sie einzelne Argumentwerte mithilfe des argv-Arrays in einem C-Programm abrufen und verarbeiten können.

Zugriff auf und Verarbeitung von Argumenten

Das Verständnis, wie man auf bestimmte Argumentwerte zugreift, ist unerlässlich für die Erstellung interaktiver Befehlszeilentools, die Benutzereingaben effektiv verarbeiten können.

1. Erstellen Sie eine neue Datei namens argument_values.c im Verzeichnis ~/project:

cd ~/project
touch argument_values.c

2. Fügen Sie den folgenden Code hinzu, um das Abrufen von Argumentwerten zu demonstrieren:

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

int main(int argc, char* argv[]) {
    // Check if at least two arguments are provided
    if (argc < 3) {
        printf("Usage: %s <name> <age>\n", argv[0]);
        return 1;
    }

    // Retrieve and store argument values
    char* name = argv[1];
    int age = atoi(argv[2]);

    // Validate age
    if (age <= 0) {
        printf("Error: Age must be a positive number.\n");
        return 1;
    }

    // Process and display argument values
    printf("Name: %s\n", name);
    printf("Age: %d\n", age);

    // Demonstrate string comparison
    if (strcmp(name, "LabEx") == 0) {
        printf("Welcome, LabEx user!\n");
    }

    return 0;
}

3. Kompilieren Sie das Programm:

gcc argument_values.c -o argument_values

4. Führen Sie das Programm mit verschiedenen Argumenten aus:

## Correct usage
./argument_values LabEx 25

## Incorrect usage
./argument_values
./argument_values John
./argument_values John -5

Beispielausgabe:

## Correct usage
Name: LabEx
Age: 25
Welcome, LabEx user!

## Incorrect usage (no arguments)
Usage:./argument_values <name> <age>

## Incorrect usage (missing age)
Usage:./argument_values <name> <age>

## Incorrect usage (invalid age)
Name: John
Error: Age must be a positive number.

Wichtige Konzepte

• argv[1], argv[2] usw. ermöglichen den Zugriff auf bestimmte Argumentwerte.
• atoi() wandelt Zeichenkettenargumente in Ganzzahlen um.
• strcmp() vergleicht Zeichenketten.
• Validieren und bereinigen Sie immer die Eingabeargumente.

Umgang mit ungültigen Argumenten

In diesem Schritt lernen Sie, wie Sie in einem C-Programm eine robuste Argumentvalidierung und Fehlerbehandlung implementieren können, um verschiedene Arten von ungültigen Eingabeszenarien zu verwalten.

Umfassende Argumentvalidierung

Die Erstellung zuverlässiger Befehlszeilentools erfordert eine sorgfältige Validierung der vom Benutzer bereitgestellten Argumente, um unerwartetes Verhalten zu vermeiden und klare Fehlermeldungen zu geben.

1. Erstellen Sie eine neue Datei namens argument_validation.c im Verzeichnis ~/project:

cd ~/project
touch argument_validation.c

2. Fügen Sie den folgenden Code hinzu, um eine umfassende Argumentvalidierung zu demonstrieren:

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

// Function to check if a string is a valid number
int is_numeric(const char* str) {
    while (*str) {
        if (!isdigit(*str)) {
            return 0;
        }
        str++;
    }
    return 1;
}

int main(int argc, char* argv[]) {
    // Check for correct number of arguments
    if (argc!= 3) {
        fprintf(stderr, "Usage: %s <username> <age>\n", argv[0]);
        fprintf(stderr, "Error: Exactly 2 arguments required.\n");
        return 1;
    }

    // Validate username
    char* username = argv[1];
    if (strlen(username) < 3 || strlen(username) > 20) {
        fprintf(stderr, "Error: Username must be between 3 and 20 characters.\n");
        return 1;
    }

    // Validate age
    char* age_str = argv[2];
    if (!is_numeric(age_str)) {
        fprintf(stderr, "Error: Age must be a positive number.\n");
        return 1;
    }

    int age = atoi(age_str);
    if (age < 0 || age > 120) {
        fprintf(stderr, "Error: Age must be between 0 and 120.\n");
        return 1;
    }

    // Process valid arguments
    printf("Username validated: %s\n", username);
    printf("Age validated: %d\n", age);

    return 0;
}

3. Kompilieren Sie das Programm:

gcc argument_validation.c -o argument_validation

4. Führen Sie das Programm mit verschiedenen Eingabeszenarien aus:

## Correct usage
./argument_validation JohnDoe 30

## Incorrect number of arguments
./argument_validation
./argument_validation JohnDoe

## Invalid username
./argument_validation Jo 30
./argument_validation JohnDoeWithAVeryLongUsername 30

## Invalid age
./argument_validation JohnDoe abc
./argument_validation JohnDoe -5
./argument_validation JohnDoe 150

Beispielausgabe:

## Correct usage
Username validated: JohnDoe
Age validated: 30

## Incorrect number of arguments
Usage:./argument_validation <username> <age>
Error: Exactly 2 arguments required.

## Invalid username
Error: Username must be between 3 and 20 characters.

## Invalid age formats
Error: Age must be a positive number.
Error: Age must be between 0 and 120.

Wichtige Konzepte

• Verwenden Sie benutzerdefinierte Validierungsfunktionen, um das Format der Argumente zu prüfen.
• Implementieren Sie mehrere Validierungsprüfungen.
• Verwenden Sie stderr für Fehlermeldungen.
• Geben Sie klare und informative Fehlermeldungen zurück.
• Geben Sie einen nicht-null Exit-Code für ungültige Eingaben zurück.

Implementierung eines einfachen Befehlszeilentools

In diesem Schritt erstellen Sie ein praktisches Befehlszeilentool, das die von Ihnen erlernten Fähigkeiten zum Parsen und Umgang mit Befehlszeilenargumenten demonstriert.

Befehlszeilen-Rechner

Sie implementieren einen einfachen Befehlszeilen-Rechner, der grundlegende arithmetische Operationen basierend auf vom Benutzer bereitgestellten Argumenten ausführt.

1. Erstellen Sie eine neue Datei namens calc.c im Verzeichnis ~/project:

cd ~/project
touch calc.c

2. Fügen Sie den folgenden Code hinzu, um einen Befehlszeilen-Rechner zu erstellen:

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

// Function prototypes
double add(double a, double b);
double subtract(double a, double b);
double multiply(double a, double b);
double divide(double a, double b);

int main(int argc, char* argv[]) {
    // Check for correct number of arguments
    if (argc!= 4) {
        fprintf(stderr, "Usage: %s <operation> <num1> <num2>\n", argv[0]);
        fprintf(stderr, "Operations: add, sub, mul, div\n");
        return 1;
    }

    // Parse operation
    char* operation = argv[1];

    // Convert arguments to numbers
    double num1 = atof(argv[2]);
    double num2 = atof(argv[3]);

    // Perform calculation based on operation
    double result = 0;
    if (strcmp(operation, "add") == 0) {
        result = add(num1, num2);
        printf("%.2f + %.2f = %.2f\n", num1, num2, result);
    } else if (strcmp(operation, "sub") == 0) {
        result = subtract(num1, num2);
        printf("%.2f - %.2f = %.2f\n", num1, num2, result);
    } else if (strcmp(operation, "mul") == 0) {
        result = multiply(num1, num2);
        printf("%.2f * %.2f = %.2f\n", num1, num2, result);
    } else if (strcmp(operation, "div") == 0) {
        // Check for division by zero
        if (num2 == 0) {
            fprintf(stderr, "Error: Division by zero\n");
            return 1;
        }
        result = divide(num1, num2);
        printf("%.2f / %.2f = %.2f\n", num1, num2, result);
    } else {
        fprintf(stderr, "Error: Invalid operation\n");
        fprintf(stderr, "Supported operations: add, sub, mul, div\n");
        return 1;
    }

    return 0;
}

// Arithmetic operation functions
double add(double a, double b) {
    return a + b;
}

double subtract(double a, double b) {
    return a - b;
}

double multiply(double a, double b) {
    return a * b;
}

double divide(double a, double b) {
    return a / b;
}

3. Kompilieren Sie das Programm:

gcc calc.c -o calc

4. Führen Sie den Rechner mit verschiedenen Operationen aus:

## Addition
./calc add 5 3

## Subtraction
./calc sub 10 4

## Multiplication
./calc mul 6 7

## Division
./calc div 15 3

## Error cases
./calc div 10 0
./calc pow 5 2

Beispielausgabe:

## Addition
5.00 + 3.00 = 8.00

## Subtraction
10.00 - 4.00 = 6.00

## Multiplication
6.00 * 7.00 = 42.00

## Division
15.00 / 3.00 = 5.00

## Division by zero
Error: Division by zero

## Invalid operation
Error: Invalid operation
Supported operations: add, sub, mul, div

Wichtige Konzepte

• Kombinieren Sie das Parsen von Argumenten mit funktionaler Logik.
• Behandeln Sie verschiedene Operationsszenarien.
• Geben Sie klare Fehlermeldungen.
• Verwenden Sie separate Funktionen für verschiedene Operationen.
• Validieren Sie die Eingabe und behandeln Sie Randfälle.

Zusammenfassung

In diesem Lab (Praktikum) lernen Sie, wie Sie Befehlszeilenargumente in der C-Programmierung parsen können. Zunächst werden Sie die grundlegenden Konzepte von Befehlszeilenargumenten verstehen, einschließlich der Parameter argc und argv in der main()-Funktion. Anschließend lernen Sie, wie Sie die Anzahl der Argumente abrufen und deren Werte auslesen können. Darüber hinaus werden Sie den Umgang mit ungültigen Argumenten untersuchen und ein einfaches Befehlszeilentool implementieren. Am Ende dieses Labs werden Sie über das Wissen und die Fähigkeiten verfügen, um Befehlszeilenargumente effektiv in Ihren C-Programmen zu nutzen.