LabEx
EntrarJunte-se

Analisar Argumentos de Linha de Comando em C

CBeginner
Pratique Agora

Introdução

Neste laboratório, você aprenderá como analisar argumentos de linha de comando em programação C. O laboratório cobre os conceitos fundamentais de argumentos de linha de comando, incluindo o acesso ao número de argumentos, a recuperação de valores de argumentos, o tratamento de argumentos inválidos e a implementação de uma ferramenta simples de linha de comando. Ao final do laboratório, você terá uma sólida compreensão de como trabalhar com argumentos de linha de comando em seus programas C.

Entender os Argumentos de Linha de Comando

Nesta etapa, você aprenderá os conceitos fundamentais de argumentos de linha de comando em programação C e como eles são passados para um programa quando ele é executado.

O que são Argumentos de Linha de Comando?

Argumentos de linha de comando são parâmetros que são passados para um programa quando ele é iniciado a partir da linha de comando. Em C, esses argumentos são recebidos pela função main() através de dois parâmetros especiais: argc e argv.

  1. Crie um novo arquivo chamado arguments_intro.c no diretório ~/project:
cd ~/project
touch arguments_intro.c
  1. Adicione o seguinte código para explorar os argumentos de linha de comando:
#include <stdio.h>

int main(int argc, char* argv[]) {
    printf("Número de argumentos: %d\n", argc);

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

    return 0;
}
  1. Compile o programa:
gcc arguments_intro.c -o arguments_intro
  1. Execute o programa com diferentes números de argumentos:
./arguments_intro
./arguments_intro Hello
./arguments_intro Hello World

Exemplo de saída:

## Quando nenhum argumento é fornecido
Número de argumentos: 1
Argumento 0: ./arguments_intro

## Com um argumento
Número de argumentos: 2
Argumento 0: ./arguments_intro
Argumento 1: Hello

## Com dois argumentos
Número de argumentos: 3
Argumento 0: ./arguments_intro
Argumento 1: Hello
Argumento 2: World

Entendendo argc e argv

  • argc (contagem de argumentos - argument count): Representa o número total de argumentos passados para o programa, incluindo o nome do próprio programa.
  • argv (vetor de argumentos - argument vector): Um array de strings contendo os argumentos reais.
  • argv[0] é sempre o nome do programa.
  • Os argumentos subsequentes começam a partir de argv[1].

Acessar o Número de Argumentos

Nesta etapa, você aprenderá como acessar e utilizar o número de argumentos passados para um programa C usando o parâmetro argc.

Verificando o Número de Argumentos

Entender como verificar o número de argumentos é crucial para criar programas de linha de comando flexíveis e robustos. Você aprenderá como validar o número de argumentos e fornecer feedback apropriado.

  1. Crie um novo arquivo chamado argument_count.c no diretório ~/project:
cd ~/project
touch argument_count.c
  1. Adicione o seguinte código para demonstrar a verificação da contagem de argumentos:
#include <stdio.h>

int main(int argc, char* argv[]) {
    // Verifique se o número correto de argumentos foi fornecido
    if (argc < 2) {
        printf("Erro: Pelo menos um argumento é necessário.\n");
        printf("Uso: %s <argumento1> [argumento2] ...\n", argv[0]);
        return 1;
    }

    // Imprima o número total de argumentos
    printf("Número total de argumentos: %d\n", argc);

    // Verifique um número máximo de argumentos
    if (argc > 4) {
        printf("Aviso: Muitos argumentos. Apenas os 3 primeiros serão processados.\n");
    }

    return 0;
}
  1. Compile o programa:
gcc argument_count.c -o argument_count
  1. Execute o programa com diferentes números de argumentos:
## Sem argumentos
./argument_count

## Um argumento
./argument_count Hello

## Múltiplos argumentos
./argument_count Hello World Lab

## Muitos argumentos
./argument_count Arg1 Arg2 Arg3 Arg4 Arg5

Exemplo de saída:

## Sem argumentos
Erro: Pelo menos um argumento é necessário.
Uso: ./argument_count <argumento1> [argumento2] ...

## Um argumento
Número total de argumentos: 2

## Múltiplos argumentos
Número total de argumentos: 4

## Muitos argumentos
Número total de argumentos: 6
Aviso: Muitos argumentos. Apenas os 3 primeiros serão processados.

Conceitos Chave

  • argc informa o número total de argumentos, incluindo o nome do programa.
  • Você pode usar argc para validar o número de argumentos.
  • Forneça instruções de uso claras quando argumentos incorretos forem fornecidos.
  • Lide com casos com poucos ou muitos argumentos de forma adequada.

Recuperar os Valores dos Argumentos

Nesta etapa, você aprenderá como recuperar e processar valores de argumentos individuais usando o array argv em um programa C.

Acessando e Processando Argumentos

Entender como acessar valores de argumentos específicos é essencial para criar ferramentas de linha de comando interativas que podem lidar com as entradas do usuário de forma eficaz.

  1. Crie um novo arquivo chamado argument_values.c no diretório ~/project:
cd ~/project
touch argument_values.c
  1. Adicione o seguinte código para demonstrar a recuperação de valores de argumentos:
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

int main(int argc, char* argv[]) {
    // Verifique se pelo menos dois argumentos foram fornecidos
    if (argc < 3) {
        printf("Uso: %s <nome> <idade>\n", argv[0]);
        return 1;
    }

    // Recupere e armazene os valores dos argumentos
    char* name = argv[1];
    int age = atoi(argv[2]);

    // Valide a idade
    if (age <= 0) {
        printf("Erro: A idade deve ser um número positivo.\n");
        return 1;
    }

    // Processe e exiba os valores dos argumentos
    printf("Nome: %s\n", name);
    printf("Idade: %d\n", age);

    // Demonstre a comparação de strings
    if (strcmp(name, "LabEx") == 0) {
        printf("Bem-vindo, usuário LabEx!\n");
    }

    return 0;
}
  1. Compile o programa:
gcc argument_values.c -o argument_values
  1. Execute o programa com diferentes argumentos:
## Uso correto
./argument_values LabEx 25

## Uso incorreto
./argument_values
./argument_values John
./argument_values John -5

Exemplo de saída:

## Uso correto
Nome: LabEx
Idade: 25
Bem-vindo, usuário LabEx!

## Uso incorreto (sem argumentos)
Uso: ./argument_values <nome> <idade>

## Uso incorreto (idade ausente)
Uso: ./argument_values <nome> <idade>

## Uso incorreto (idade inválida)
Nome: John
Erro: A idade deve ser um número positivo.

Conceitos Chave

  • argv[1], argv[2], etc., acessam valores de argumentos específicos.
  • atoi() converte argumentos de string em inteiros.
  • strcmp() compara strings.
  • Sempre valide e sanitize os argumentos de entrada.

Lidar com Argumentos Inválidos

Nesta etapa, você aprenderá como implementar uma validação de argumentos robusta e tratamento de erros em um programa C para gerenciar vários tipos de cenários de entrada inválida.

Validação Abrangente de Argumentos

Criar ferramentas de linha de comando confiáveis requer uma validação cuidadosa dos argumentos fornecidos pelo usuário para evitar comportamentos inesperados e fornecer mensagens de erro claras.

  1. Crie um novo arquivo chamado argument_validation.c no diretório ~/project:
cd ~/project
touch argument_validation.c
  1. Adicione o seguinte código para demonstrar a validação abrangente de argumentos:
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>

// Função para verificar se uma string é um número válido
int is_numeric(const char* str) {
    while (*str) {
        if (!isdigit(*str)) {
            return 0;
        }
        str++;
    }
    return 1;
}

int main(int argc, char* argv[]) {
    // Verifique o número correto de argumentos
    if (argc != 3) {
        fprintf(stderr, "Uso: %s <nome_de_usuário> <idade>\n", argv[0]);
        fprintf(stderr, "Erro: Exatamente 2 argumentos são necessários.\n");
        return 1;
    }

    // Valide o nome de usuário
    char* username = argv[1];
    if (strlen(username) < 3 || strlen(username) > 20) {
        fprintf(stderr, "Erro: O nome de usuário deve ter entre 3 e 20 caracteres.\n");
        return 1;
    }

    // Valide a idade
    char* age_str = argv[2];
    if (!is_numeric(age_str)) {
        fprintf(stderr, "Erro: A idade deve ser um número positivo.\n");
        return 1;
    }

    int age = atoi(age_str);
    if (age < 0 || age > 120) {
        fprintf(stderr, "Erro: A idade deve estar entre 0 e 120.\n");
        return 1;
    }

    // Processe argumentos válidos
    printf("Nome de usuário validado: %s\n", username);
    printf("Idade validada: %d\n", age);

    return 0;
}
  1. Compile o programa:
gcc argument_validation.c -o argument_validation
  1. Execute o programa com vários cenários de entrada:
## Uso correto
./argument_validation JohnDoe 30

## Número incorreto de argumentos
./argument_validation
./argument_validation JohnDoe

## Nome de usuário inválido
./argument_validation Jo 30
./argument_validation JohnDoeWithAVeryLongUsername 30

## Idade inválida
./argument_validation JohnDoe abc
./argument_validation JohnDoe -5
./argument_validation JohnDoe 150

Exemplo de saída:

## Uso correto
Nome de usuário validado: JohnDoe
Idade validada: 30

## Número incorreto de argumentos
Uso: ./argument_validation <nome_de_usuário> <idade>
Erro: Exatamente 2 argumentos são necessários.

## Nome de usuário inválido
Erro: O nome de usuário deve ter entre 3 e 20 caracteres.

## Formatos de idade inválidos
Erro: A idade deve ser um número positivo.
Erro: A idade deve estar entre 0 e 120.

Conceitos Chave

  • Use funções de validação personalizadas para verificar os formatos dos argumentos
  • Implemente múltiplas verificações de validação
  • Use stderr para mensagens de erro
  • Forneça feedback de erro claro e informativo
  • Retorne códigos de saída diferentes de zero para entradas inválidas

Implementar uma Ferramenta de Linha de Comando Simples

Nesta etapa, você criará uma ferramenta prática de linha de comando que demonstra as habilidades que você aprendeu sobre análise e manipulação de argumentos de linha de comando.

Ferramenta de Linha de Comando Calculadora

Você implementará uma calculadora simples de linha de comando que realiza operações aritméticas básicas com base nos argumentos fornecidos pelo usuário.

  1. Crie um novo arquivo chamado calc.c no diretório ~/project:
cd ~/project
touch calc.c
  1. Adicione o seguinte código para criar uma calculadora de linha de comando:
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

// Protótipos de função
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[]) {
    // Verifique o número correto de argumentos
    if (argc != 4) {
        fprintf(stderr, "Uso: %s <operação> <num1> <num2>\n", argv[0]);
        fprintf(stderr, "Operações: add, sub, mul, div\n");
        return 1;
    }

    // Analise a operação
    char* operation = argv[1];

    // Converta os argumentos em números
    double num1 = atof(argv[2]);
    double num2 = atof(argv[3]);

    // Realize o cálculo com base na operação
    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) {
        // Verifique a divisão por zero
        if (num2 == 0) {
            fprintf(stderr, "Erro: Divisão por zero\n");
            return 1;
        }
        result = divide(num1, num2);
        printf("%.2f / %.2f = %.2f\n", num1, num2, result);
    } else {
        fprintf(stderr, "Erro: Operação inválida\n");
        fprintf(stderr, "Operações suportadas: add, sub, mul, div\n");
        return 1;
    }

    return 0;
}

// Funções de operação aritmética
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;
}
  1. Compile o programa:
gcc calc.c -o calc
  1. Execute a calculadora com diferentes operações:
## Adição
./calc add 5 3

## Subtração
./calc sub 10 4

## Multiplicação
./calc mul 6 7

## Divisão
./calc div 15 3

## Casos de erro
./calc div 10 0
./calc pow 5 2

Exemplo de saída:

## Adição
5.00 + 3.00 = 8.00

## Subtração
10.00 - 4.00 = 6.00

## Multiplicação
6.00 * 7.00 = 42.00

## Divisão
15.00 / 3.00 = 5.00

## Divisão por zero
Erro: Divisão por zero

## Operação inválida
Erro: Operação inválida
Operações suportadas: add, sub, mul, div

Conceitos Chave

  • Combine a análise de argumentos com a lógica funcional
  • Lide com diferentes cenários de operação
  • Forneça mensagens de erro claras
  • Use funções separadas para diferentes operações
  • Valide a entrada e lide com casos extremos

Resumo

Neste laboratório, você aprenderá como analisar argumentos de linha de comando em programação C. Primeiro, você entenderá os conceitos fundamentais de argumentos de linha de comando, incluindo os parâmetros argc e argv na função main(). Em seguida, você aprenderá como acessar o número de argumentos e recuperar seus valores. Além disso, você explorará o tratamento de argumentos inválidos e implementará uma ferramenta simples de linha de comando. Ao final deste laboratório, você terá o conhecimento e as habilidades para utilizar efetivamente argumentos de linha de comando em seus programas C.

Relacionados C Cursos
Programação C para Iniciantes

Programação C para Iniciantes

c
Construindo Flappy Bird Usando C

Construindo Flappy Bird Usando C

c
Criando uma Calculadora Simples Usando C

Criando uma Calculadora Simples Usando C

c