C Academy · Aula

getopt

Análise padrão de opções.

getopt é uma aula grátis de C Academy no CoddyKit. Esta é a aula 3 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.

O que é getopt?

getopt é uma função POSIX que analisa opções de um único caractere para você, seguindo as convenções padrão do Unix.

Ela está em <unistd.h> e elimina a maior parte do código repetitivo da análise manual de sinalizadores.

#include <stdio.h>
#include <unistd.h>

int main(int argc, char *argv[]) {
    int opt;
    while ((opt = getopt(argc, argv, "v")) != -1) {
        if (opt == 'v') printf("verbose on\n");
    }
    return 0;
}

A cadeia de opções

O terceiro argumento de getopt é a cadeia de opções: uma lista de letras de opções válidas.

"abc" significa que -a, -b e -c são todos aceitos como sinalizadores booleanos.

#include <stdio.h>
#include <unistd.h>

int main(int argc, char *argv[]) {
    int opt;
    while ((opt = getopt(argc, argv, "abc")) != -1) {
        printf("saw option -%c\n", opt);
    }
    return 0;
}

O loop de análise

getopt retorna o próximo caractere de opção a cada chamada, ou -1 quando termina.

O padrão é um loop while com um switch dentro para encaminhar o caractere retornado.

#include <stdio.h>
#include <unistd.h>

int main(int argc, char *argv[]) {
    int opt;
    while ((opt = getopt(argc, argv, "xy")) != -1) {
        switch (opt) {
            case 'x': printf("x set\n"); break;
            case 'y': printf("y set\n"); break;
        }
    }
    return 0;
}

Opções com argumentos

Coloque dois-pontos depois de uma letra na cadeia de opções para indicar que ela recebe um valor. "o:" significa que -o exige um argumento.

O valor fica disponível na variável global optarg.

#include <stdio.h>
#include <unistd.h>

int main(int argc, char *argv[]) {
    int opt;
    while ((opt = getopt(argc, argv, "o:")) != -1) {
        if (opt == 'o') printf("output = %s\n", optarg);
    }
    return 0;
}

Combinando sinalizadores e opções com valores

Você pode misturar opções booleanas e opções que recebem valores em uma única cadeia de opções. Aqui, -v é um sinalizador e -n recebe um número.

getopt também permite agrupar sinalizadores, como em -vn 5.

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

int main(int argc, char *argv[]) {
    int opt, verbose = 0, n = 0;
    while ((opt = getopt(argc, argv, "vn:")) != -1) {
        if (opt == 'v') verbose = 1;
        else if (opt == 'n') n = atoi(optarg);
    }
    printf("verbose=%d n=%d\n", verbose, n);
    return 0;
}

Tratando opções desconhecidas

Quando getopt encontra uma opção que não está na cadeia de opções, ele retorna '?' e imprime um erro (a menos que você silencie esse comportamento).

Adicione um case '?' para tratar uma entrada inválida de maneira adequada.

#include <stdio.h>
#include <unistd.h>

int main(int argc, char *argv[]) {
    int opt;
    while ((opt = getopt(argc, argv, "a")) != -1) {
        switch (opt) {
            case 'a': printf("a\n"); break;
            case '?': printf("unknown option\n"); break;
        }
    }
    return 0;
}

Argumentos obrigatórios ausentes

Se uma opção que recebe um valor for fornecida sem esse valor, o comportamento de getopt dependerá da cadeia de opções.

Começar a cadeia de opções com dois-pontos (":o:") faz getopt retornar ':' para um argumento ausente, permitindo informá-lo com precisão.

#include <stdio.h>
#include <unistd.h>

int main(int argc, char *argv[]) {
    int opt;
    while ((opt = getopt(argc, argv, ":f:")) != -1) {
        if (opt == 'f') printf("file=%s\n", optarg);
        else if (opt == ':') printf("option needs a value\n");
    }
    return 0;
}

optind: onde a análise parou

Após o loop, o valor global optind contém, em argv, o índice do primeiro argumento que não é uma opção.

Use-o para processar os argumentos posicionais restantes, como nomes de arquivos.

#include <stdio.h>
#include <unistd.h>

int main(int argc, char *argv[]) {
    int opt;
    while ((opt = getopt(argc, argv, "v")) != -1) { }
    for (int i = optind; i < argc; i++)
        printf("positional: %s\n", argv[i]);
    return 0;
}

Silenciando as mensagens de getopt

Por padrão, getopt imprime suas próprias mensagens de erro em stderr. Defina o valor global opterr como 0 para suprimi-las e tratar os erros por conta própria.

#include <stdio.h>
#include <unistd.h>

extern int opterr;

int main(int argc, char *argv[]) {
    opterr = 0;
    int opt;
    while ((opt = getopt(argc, argv, "a")) != -1) {
        if (opt == '?') printf("bad option, handled quietly\n");
    }
    return 0;
}

Identificando a opção inválida

Quando getopt retorna '?', o valor global optopt contém o caractere da opção problemática.

Isso permite imprimir uma mensagem útil indicando exatamente qual sinalizador estava incorreto.

#include <stdio.h>
#include <unistd.h>

int main(int argc, char *argv[]) {
    int opt;
    while ((opt = getopt(argc, argv, "a")) != -1) {
        if (opt == '?')
            printf("Unrecognized option: -%c\n", optopt);
    }
    return 0;
}

Observação sobre opções longas

O getopt simples oferece suporte apenas a opções de uma letra. Para opções longas, como --verbose, os sistemas GNU fornecem getopt_long em <getopt.h>.

Ele usa o mesmo loop, mas adiciona uma tabela de descritores de opções longas.

#include <stdio.h>
#include <unistd.h>

int main(int argc, char *argv[]) {
    printf("getopt parses %d short options\n", argc > 1 ? argc - 1 : 0);
    return 0;
}

Verificação rápida

Teste sua compreensão da sintaxe da cadeia de opções de getopt.

Recapitulação

Você aprendeu a análise padrão de opções com getopt:

Repita o loop enquanto getopt(argc, argv, optstring) não for -1 e encaminhe o resultado com um switch.
Dois-pontos depois de uma letra significa que ela recebe um valor, encontrado em optarg.
optind aponta para o primeiro argumento posicional restante.
As variáveis globais opterr, optopt e os dois-pontos iniciais controlam o tratamento de erros.

Perguntas Frequentes

A aula “getopt” é grátis?

Sim — o texto completo de “getopt” é 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 “getopt”?

Análise padrão de opções. 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 3 de 4.

Quanto tempo leva a aula “getopt”?

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

← Voltar para C Academy