Analyser les arguments de ligne de commande en C

Introduction

Dans ce laboratoire (lab), vous apprendrez à analyser (parser) les arguments de ligne de commande en programmation C. Le laboratoire couvre les concepts fondamentaux des arguments de ligne de commande, notamment l'accès au nombre d'arguments, la récupération des valeurs des arguments, la gestion des arguments invalides et la mise en œuvre d'un outil de ligne de commande simple. À la fin du laboratoire, vous aurez une bonne compréhension de la manipulation des arguments de ligne de commande dans vos programmes C.

Comprendre les arguments de ligne de commande

Dans cette étape, vous apprendrez les concepts fondamentaux des arguments de ligne de commande en programmation C et comment ils sont transmis à un programme lorsqu'il est exécuté.

Qu'est-ce que les arguments de ligne de commande?

Les arguments de ligne de commande sont des paramètres qui sont transmis à un programme lorsqu'il est lancé depuis la ligne de commande. En C, ces arguments sont reçus par la fonction main() grâce à deux paramètres spéciaux : argc et argv.

1. Créez un nouveau fichier nommé arguments_intro.c dans le répertoire ~/project :

cd ~/project
touch arguments_intro.c

2. Ajoutez le code suivant pour explorer les arguments de ligne de commande :

#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. Compilez le programme :

gcc arguments_intro.c -o arguments_intro

4. Exécutez le programme avec différents nombres d'arguments :

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

Exemple de sortie :

## 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

Comprendre argc et argv

• argc (compte d'arguments) : Représente le nombre total d'arguments transmis au programme, y compris le nom du programme lui-même.
• argv (vecteur d'arguments) : Un tableau de chaînes de caractères contenant les arguments réels.
• argv[0] est toujours le nom du programme.
• Les arguments suivants commencent à partir de argv[1].

Accéder au nombre d'arguments

Dans cette étape, vous apprendrez à accéder et à utiliser le nombre d'arguments transmis à un programme C en utilisant le paramètre argc.

Vérifier le nombre d'arguments

Comprendre comment vérifier le nombre d'arguments est crucial pour créer des programmes de ligne de commande flexibles et robustes. Vous apprendrez à valider le nombre d'arguments et à fournir des commentaires appropriés.

1. Créez un nouveau fichier nommé argument_count.c dans le répertoire ~/project :

cd ~/project
touch argument_count.c

2. Ajoutez le code suivant pour démontrer la vérification du nombre d'arguments :

#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. Compilez le programme :

gcc argument_count.c -o argument_count

4. Exécutez le programme avec différents nombres d'arguments :

## 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

Exemple de sortie :

## 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.

Concepts clés

• argc vous indique le nombre total d'arguments, y compris le nom du programme.
• Vous pouvez utiliser argc pour valider le nombre d'arguments.
• Fournissez des instructions d'utilisation claires lorsque des arguments incorrects sont donnés.
• Gérez gracieusement les cas où il y a trop peu ou trop d'arguments.

Récupérer les valeurs des arguments

Dans cette étape, vous apprendrez à récupérer et à traiter les valeurs individuelles des arguments en utilisant le tableau argv dans un programme C.

Accéder et traiter les arguments

Comprendre comment accéder aux valeurs spécifiques des arguments est essentiel pour créer des outils de ligne de commande interactifs capables de gérer efficacement les entrées utilisateur.

1. Créez un nouveau fichier nommé argument_values.c dans le répertoire ~/project :

cd ~/project
touch argument_values.c

2. Ajoutez le code suivant pour démontrer la récupération des valeurs des arguments :

#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. Compilez le programme :

gcc argument_values.c -o argument_values

4. Exécutez le programme avec différents arguments :

## Correct usage
./argument_values LabEx 25

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

Exemple de sortie :

## 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.

Concepts clés

• argv[1], argv[2], etc., permettent d'accéder aux valeurs spécifiques des arguments.
• atoi() convertit les arguments de type chaîne de caractères en entiers.
• strcmp() compare des chaînes de caractères.
• Toujours valider et nettoyer les arguments d'entrée.

Gérer les arguments invalides

Dans cette étape, vous apprendrez à implémenter une validation robuste des arguments et une gestion des erreurs dans un programme C pour gérer différents types de scénarios d'entrée invalide.

Validation complète des arguments

La création d'outils de ligne de commande fiables nécessite une validation minutieuse des arguments fournis par l'utilisateur pour éviter tout comportement inattendu et fournir des messages d'erreur clairs.

1. Créez un nouveau fichier nommé argument_validation.c dans le répertoire ~/project :

cd ~/project
touch argument_validation.c

2. Ajoutez le code suivant pour démontrer la validation complète des arguments :

#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. Compilez le programme :

gcc argument_validation.c -o argument_validation

4. Exécutez le programme avec différents scénarios d'entrée :

## 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

Exemple de sortie :

## 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.

Concepts clés

• Utilisez des fonctions de validation personnalisées pour vérifier les formats des arguments
• Implémentez plusieurs vérifications de validation
• Utilisez stderr pour les messages d'erreur
• Fournissez des commentaires d'erreur clairs et informatifs
• Retournez des codes de sortie non nuls pour les entrées invalides

Implémenter un outil en ligne de commande simple

Dans cette étape, vous allez créer un outil pratique de ligne de commande qui met en œuvre les compétences que vous avez acquises concernant l'analyse et la gestion des arguments de ligne de commande.

Outil de calculatrice en ligne de commande

Vous allez implémenter une simple calculatrice en ligne de commande qui effectue des opérations arithmétiques de base en fonction des arguments fournis par l'utilisateur.

1. Créez un nouveau fichier nommé calc.c dans le répertoire ~/project :

cd ~/project
touch calc.c

2. Ajoutez le code suivant pour créer une calculatrice en ligne de commande :

#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. Compilez le programme :

gcc calc.c -o calc

4. Exécutez la calculatrice avec différentes opérations :

## 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

Exemple de sortie :

## 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

Concepts clés

• Combiner l'analyse des arguments avec la logique fonctionnelle
• Gérer différents scénarios d'opération
• Fournir des messages d'erreur clairs
• Utiliser des fonctions distinctes pour différentes opérations
• Valider les entrées et gérer les cas limites

Résumé

Dans ce laboratoire, vous apprendrez à analyser les arguments de ligne de commande en programmation C. Tout d'abord, vous comprendrez les concepts fondamentaux des arguments de ligne de commande, y compris les paramètres argc et argv dans la fonction main(). Vous apprendrez ensuite à accéder au nombre d'arguments et à récupérer leurs valeurs. De plus, vous explorerez la gestion des arguments invalides et implémenterez un outil simple de ligne de commande. À la fin de ce laboratoire, vous disposerez des connaissances et des compétences nécessaires pour utiliser efficacement les arguments de ligne de commande dans vos programmes C.