Analizar Argumentos de Línea de Comandos en C

Introducción

En este laboratorio, aprenderás cómo analizar (parsear) argumentos de línea de comandos en programación C. El laboratorio cubre los conceptos fundamentales de los argumentos de línea de comandos, incluyendo el acceso al número de argumentos, la recuperación de los valores de los argumentos, el manejo de argumentos inválidos y la implementación de una herramienta simple de línea de comandos. Al final del laboratorio, tendrás una comprensión sólida de cómo trabajar con argumentos de línea de comandos en tus programas en C.

Comprender los Argumentos de Línea de Comandos

En este paso, aprenderás los conceptos fundamentales de los argumentos de línea de comandos en programación C y cómo se pasan a un programa cuando se ejecuta.

¿Qué son los Argumentos de Línea de Comandos?

Los argumentos de línea de comandos son parámetros que se pasan a un programa cuando se inicia desde la línea de comandos. En C, estos argumentos son recibidos por la función main() a través de dos parámetros especiales: argc y argv.

Crea un nuevo archivo llamado arguments_intro.c en el directorio ~/project:

cd ~/project
touch arguments_intro.c

Agrega el siguiente código para explorar los argumentos de línea de comandos:

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

Compila el programa:

gcc arguments_intro.c -o arguments_intro

Ejecuta el programa con diferentes números de argumentos:

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

Ejemplo de salida:

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

Comprendiendo `argc` y `argv`

argc (conteo de argumentos): Representa el número total de argumentos pasados al programa, incluyendo el nombre del programa en sí.
argv (vector de argumentos): Un arreglo de cadenas que contiene los argumentos reales.
argv[0] siempre es el nombre del programa.
Los argumentos subsiguientes comienzan desde argv[1].

Acceder al Número de Argumentos

En este paso, aprenderás cómo acceder y utilizar el número de argumentos pasados a un programa en C utilizando el parámetro argc.

Verificar el Número de Argumentos

Comprender cómo verificar el número de argumentos es crucial para crear programas de línea de comandos flexibles y robustos. Aprenderás cómo validar el número de argumentos y proporcionar una retroalimentación adecuada.

Crea un nuevo archivo llamado argument_count.c en el directorio ~/project:

cd ~/project
touch argument_count.c

Agrega el siguiente código para demostrar la verificación del número de argumentos:

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

Compila el programa:

gcc argument_count.c -o argument_count

Ejecuta el programa con diferentes números de argumentos:

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

Ejemplo de salida:

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

Conceptos Clave

argc te indica el número total de argumentos, incluyendo el nombre del programa.
Puedes utilizar argc para validar el número de argumentos.
Proporciona instrucciones de uso claras cuando se dan argumentos incorrectos.
Maneja de manera adecuada los casos con demasiados o muy pocos argumentos.

Recuperar Valores de Argumentos

En este paso, aprenderás cómo recuperar y procesar los valores individuales de los argumentos utilizando el arreglo argv en un programa en C.

Acceder y Procesar Argumentos

Comprender cómo acceder a valores específicos de los argumentos es esencial para crear herramientas interactivas de línea de comandos que puedan manejar eficazmente las entradas de los usuarios.

Crea un nuevo archivo llamado argument_values.c en el directorio ~/project:

cd ~/project
touch argument_values.c

Agrega el siguiente código para demostrar la recuperación de valores de argumentos:

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

Compila el programa:

gcc argument_values.c -o argument_values

Ejecuta el programa con diferentes argumentos:

## Correct usage
./argument_values LabEx 25

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

Ejemplo de salida:

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

Conceptos Clave

argv[1], argv[2], etc., acceden a valores específicos de los argumentos.
atoi() convierte argumentos de tipo cadena a enteros.
strcmp() compara cadenas.
Siempre valida y sanitiza los argumentos de entrada.

Manejar Argumentos Inválidos

En este paso, aprenderás cómo implementar una validación de argumentos sólida y un manejo de errores en un programa en C para manejar varios tipos de escenarios de entrada inválida.

Validación Integral de Argumentos

Crear herramientas confiables de línea de comandos requiere una cuidadosa validación de los argumentos proporcionados por el usuario para prevenir comportamientos inesperados y proporcionar mensajes de error claros.

Crea un nuevo archivo llamado argument_validation.c en el directorio ~/project:

cd ~/project
touch argument_validation.c

Agrega el siguiente código para demostrar la validación integral de argumentos:

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

Compila el programa:

gcc argument_validation.c -o argument_validation

Ejecuta el programa con varios escenarios de entrada:

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

Ejemplo de salida:

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

Conceptos Clave

Utiliza funciones de validación personalizadas para verificar los formatos de los argumentos.
Implementa múltiples comprobaciones de validación.
Utiliza stderr para los mensajes de error.
Proporciona una retroalimentación de error clara e informativa.
Devuelve códigos de salida distintos de cero para entradas inválidas.

Implementar una Herramienta Simple de Línea de Comandos

En este paso, crearás una herramienta práctica de línea de comandos que demuestre las habilidades que has aprendido sobre el análisis y manejo de argumentos de línea de comandos.

Herramienta de Cálculo de Línea de Comandos

Implementarás una calculadora simple de línea de comandos que realice operaciones aritméticas básicas basadas en los argumentos proporcionados por el usuario.

Crea un nuevo archivo llamado calc.c en el directorio ~/project:

cd ~/project
touch calc.c

Agrega el siguiente código para crear una calculadora de línea de comandos:

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

Compila el programa:

gcc calc.c -o calc

Ejecuta la calculadora con diferentes operaciones:

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

Ejemplo de salida:

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

Conceptos Clave

Combina el análisis de argumentos con la lógica funcional.
Maneja diferentes escenarios de operación.
Proporciona mensajes de error claros.
Utiliza funciones separadas para diferentes operaciones.
Valida la entrada y maneja casos extremos.

Resumen

En este laboratorio, aprenderás cómo analizar (parsear) argumentos de línea de comandos en programación C. Primero, entenderás los conceptos fundamentales de los argumentos de línea de comandos, incluyendo los parámetros argc y argv en la función main(). Luego, aprenderás cómo acceder al número de argumentos y recuperar sus valores. Además, explorarás el manejo de argumentos inválidos e implementarás una herramienta simple de línea de comandos. Al final de este laboratorio, tendrás el conocimiento y las habilidades necesarias para utilizar eficazmente los argumentos de línea de comandos en tus programas en C.

Analizar Argumentos de Línea de Comandos en C

Introducción

Comprender los Argumentos de Línea de Comandos

¿Qué son los Argumentos de Línea de Comandos?

Comprendiendo argc y argv

Acceder al Número de Argumentos

Verificar el Número de Argumentos

Conceptos Clave

Recuperar Valores de Argumentos

Acceder y Procesar Argumentos

Conceptos Clave

Manejar Argumentos Inválidos

Validación Integral de Argumentos

Conceptos Clave

Implementar una Herramienta Simple de Línea de Comandos

Herramienta de Cálculo de Línea de Comandos

Conceptos Clave

Resumen

Comprendiendo `argc` y `argv`