0Pricing
C Academy · Aula

Analisando opções

Lide com flags.

Analisando opções é uma aula grátis de C Academy no CoddyKit. Esta é a aula 2 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de C Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de C Academy inclui 4 aulas no total.

Opções versus argumentos posicionais

Os argumentos da linha de comando vêm em dois tipos. Os argumentos posicionais são valores como nomes de arquivos. As opções (também chamadas de sinalizadores) começam com um hífen, como -v ou --help.

Esta lição mostra como detectar e tratar sinalizadores manualmente.

#include <stdio.h>

int main(int argc, char *argv[]) {
    for (int i = 1; i < argc; i++) {
        if (argv[i][0] == '-')
            printf("option: %s\n", argv[i]);
        else
            printf("value:  %s\n", argv[i]);
    }
    return 0;
}

Detectando um sinalizador

Para verificar um sinalizador específico, compare cada argumento com strcmp.

Aqui, definimos um booleano quando encontramos -v, que ativa o modo detalhado.

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

int main(int argc, char *argv[]) {
    int verbose = 0;
    for (int i = 1; i < argc; i++) {
        if (strcmp(argv[i], "-v") == 0)
            verbose = 1;
    }
    printf("verbose = %d\n", verbose);
    return 0;
}

Dando suporte a opções longas

Muitas ferramentas aceitam tanto uma forma curta (-h) quanto uma forma longa (--help).

Verifique as duas grafias com duas comparações unidas por ||.

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

int main(int argc, char *argv[]) {
    for (int i = 1; i < argc; i++) {
        if (strcmp(argv[i], "-h") == 0 ||
            strcmp(argv[i], "--help") == 0) {
            printf("Usage: prog [options]\n");
            return 0;
        }
    }
    printf("No help requested\n");
    return 0;
}

Opções que recebem um valor

Alguns sinalizadores precisam de um argumento, como -o output.txt. Quando você encontra esse sinalizador, o elemento seguinte de argv é seu valor.

Avance o índice do loop e verifique se você não ultrapassou o final.

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

int main(int argc, char *argv[]) {
    const char *output = "default.txt";
    for (int i = 1; i < argc; i++) {
        if (strcmp(argv[i], "-o") == 0 && i + 1 < argc) {
            output = argv[++i];
        }
    }
    printf("Output file: %s\n", output);
    return 0;
}

Tratando o valor ausente

Se -o for o último argumento, não haverá um valor depois dele. Ler argv[i+1] ultrapassaria os limites.

Sempre teste i + 1 < argc antes de consumir o próximo token e, caso contrário, informe um erro.

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

int main(int argc, char *argv[]) {
    for (int i = 1; i < argc; i++) {
        if (strcmp(argv[i], "-n") == 0) {
            if (i + 1 >= argc) {
                printf("Error: -n needs a value\n");
                return 1;
            }
            printf("n = %s\n", argv[++i]);
        }
    }
    return 0;
}

Combinando sinalizadores booleanos e valores

Um analisador realista acompanha vários sinalizadores ao mesmo tempo: alguns booleanos e outros com valores. Use variáveis separadas para cada configuração.

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

int main(int argc, char *argv[]) {
    int verbose = 0;
    const char *name = "world";
    for (int i = 1; i < argc; i++) {
        if (strcmp(argv[i], "-v") == 0) verbose = 1;
        else if (strcmp(argv[i], "-name") == 0 && i+1 < argc) name = argv[++i];
    }
    if (verbose) printf("verbose mode\n");
    printf("Hello, %s\n", name);
    return 0;
}

Reconhecendo o fim das opções

Por convenção, um -- isolado marca o fim das opções. Tudo depois dele é tratado como argumento posicional, mesmo que comece com um hífen.

Isso permite que os usuários passem nomes de arquivos que começam com -.

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

int main(int argc, char *argv[]) {
    int opts_done = 0;
    for (int i = 1; i < argc; i++) {
        if (!opts_done && strcmp(argv[i], "--") == 0) {
            opts_done = 1;
            continue;
        }
        printf("%s: %s\n", opts_done ? "value" : "token", argv[i]);
    }
    return 0;
}

Coletando argumentos posicionais

Muitas vezes, você quer sinalizadores e uma lista de arquivos. Ignore as opções reconhecidas e armazene o restante como argumentos posicionais.

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

int main(int argc, char *argv[]) {
    for (int i = 1; i < argc; i++) {
        if (argv[i][0] == '-') continue;
        printf("file: %s\n", argv[i]);
    }
    return 0;
}

Tratamento de opções desconhecidas

Uma ferramenta amigável informa os sinalizadores desconhecidos em vez de ignorá-los silenciosamente. Compare-os com suas opções conhecidas e, caso contrário, emita um aviso.

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

int main(int argc, char *argv[]) {
    for (int i = 1; i < argc; i++) {
        if (argv[i][0] != '-') continue;
        if (strcmp(argv[i], "-v") != 0)
            printf("Unknown option: %s\n", argv[i]);
    }
    return 0;
}

Convertendo valores de opções

Os valores das opções chegam como cadeias de caracteres. Converta os valores numéricos com strtol, que também informa erros de análise por meio de um ponteiro para o fim.

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

int main(int argc, char *argv[]) {
    int count = 1;
    for (int i = 1; i < argc; i++) {
        if (strcmp(argv[i], "-c") == 0 && i+1 < argc)
            count = (int) strtol(argv[++i], NULL, 10);
    }
    printf("count = %d\n", count);
    return 0;
}

Por que um analisador real ajuda

A análise manual funciona, mas fica confusa com sinalizadores curtos combinados (-vf), a sintaxe com = (--name=foo) e as regras de ordenação.

A função padrão getopt, apresentada a seguir, trata essas convenções para você.

#include <stdio.h>

int main(int argc, char *argv[]) {
    printf("Parsed %d tokens manually\n", argc - 1);
    return 0;
}

Verificação rápida

Teste sua compreensão das armadilhas da análise de opções.

Recapitulação

Você aprendeu a analisar opções manualmente:

  • Os sinalizadores começam com -; compare-os com strcmp.
  • Dê suporte às formas curta e longa com ||.
  • As opções que recebem valores consomem o token seguinte — proteja o acesso com i + 1 < argc.
  • -- encerra a análise de opções; informe sinalizadores desconhecidos; converta valores numéricos com strtol.

Perguntas Frequentes

A aula “Analisando opções” é grátis?

Sim — o texto completo de “Analisando opções” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de C Academy, atualize para CoddyKit PRO. O curso de C Academy inclui 4 aulas no total.

O que vou aprender em “Analisando opções”?

Lide com flags. Você pratica C Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar C Academy?

Nenhuma experiência prévia é necessária. C Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 2 de 4.

Quanto tempo leva a aula “Analisando opções”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de C Academy?

Sim. Cada aula de C Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

  1. argc e argv
  2. Analisando opções
  3. getopt
  4. Criando uma ferramenta CLI
← Voltar para C Academy