Analyser les options
Gérez les indicateurs
Analyser les options est une leçon C Academy gratuite sur CoddyKit. Ceci est la leçon 2 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage C Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours C Academy comprend 4 leçons au total.
Options et arguments positionnels
Les arguments de la ligne de commande se présentent sous deux formes. Les arguments positionnels sont des valeurs comme des noms de fichiers. Les options (également appelées indicateurs) commencent par un tiret, comme -v ou --help.
Cette leçon montre comment détecter et traiter manuellement les indicateurs.
#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;
}Détecter un indicateur
Pour vérifier la présence d'un indicateur précis, comparez chaque argument avec strcmp.
Nous définissons ici une valeur booléenne lorsque nous rencontrons -v, afin d'activer le mode verbeux.
#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;
}Prendre en charge les options longues
De nombreux outils acceptent à la fois une forme courte (-h) et une forme longue (--help).
Vérifiez l'une ou l'autre écriture à l'aide de deux comparaisons reliées par ||.
#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;
}Options qui prennent une valeur
Certains indicateurs nécessitent un argument, comme -o output.txt. Lorsque vous rencontrez un tel indicateur, l'élément suivant de argv contient sa valeur.
Avancez l'indice de boucle et vérifiez que vous n'avez pas dépassé la fin.
#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;
}Gérer la valeur manquante
Si -o est le dernier argument, aucune valeur ne le suit. Lire argv[i+1] dépasserait les limites du tableau.
Testez toujours i + 1 < argc avant de consommer le jeton suivant, et signalez une erreur dans le cas contraire.
#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;
}Combiner indicateurs booléens et valeurs
Un analyseur réaliste suit plusieurs indicateurs à la fois : certains booléens, d'autres associés à des valeurs. Utilisez une variable distincte pour chaque réglage.
#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;
}Reconnaître la fin des options
Par convention, un -- seul marque la fin des options. Tout ce qui le suit est traité comme un argument positionnel, même si cela commence par un tiret.
Les utilisateurs peuvent ainsi transmettre des noms de fichiers qui commencent par -.
#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;
}Rassembler les arguments positionnels
Vous souhaitez souvent accepter des indicateurs ainsi qu'une liste de fichiers. Ignorez les options reconnues et enregistrez le reste comme arguments positionnels.
#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;
}Gérer les options inconnues
Un outil convivial signale les indicateurs inconnus au lieu de les ignorer silencieusement. Comparez-les avec vos options connues et affichez un avertissement dans le cas contraire.
#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;
}Convertir les valeurs des options
Les valeurs des options sont reçues sous forme de chaînes. Convertissez les valeurs numériques avec strtol, qui signale également les erreurs d'analyse au moyen d'un pointeur de fin.
#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;
}Pourquoi un véritable analyseur est utile
L'analyse manuelle fonctionne, mais devient vite difficile à gérer avec les indicateurs courts combinés (-vf), la syntaxe avec = (--name=foo) et les règles d'ordre.
La fonction standard getopt, présentée ensuite, gère ces conventions à votre place.
#include <stdio.h>
int main(int argc, char *argv[]) {
printf("Parsed %d tokens manually\n", argc - 1);
return 0;
}Vérification rapide
Testez votre compréhension des pièges de l'analyse des options.
Récapitulatif
Vous avez appris à analyser manuellement les options :
- Les indicateurs commencent par
-; comparez-les avecstrcmp. - Prenez en charge les formes courtes et longues avec
||. - Les options qui prennent une valeur consomment le jeton suivant — protégez cet accès avec
i + 1 < argc. --termine l'analyse des options ; signalez les indicateurs inconnus ; convertissez les valeurs numériques avecstrtol.
Questions Fréquemment Posées
La leçon « Analyser les options » est-elle gratuite ?
Oui — le texte complet de « Analyser les options » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours C Academy, passe à CoddyKit PRO. Le cours C Academy comprend 4 leçons au total.
Qu'est-ce que j'apprendrai dans « Analyser les options » ?
Gérez les indicateurs Tu pratiques C Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.
Dois-je avoir de l'expérience pour commencer C Academy ?
Aucune expérience préalable n'est requise. C Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 2 sur 4.
Combien de temps prend la leçon « Analyser les options » ?
La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.
Peux-tu écrire et exécuter du code dans cette leçon C Academy ?
Oui. Chaque leçon C Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.
Toutes les leçons de ce cours
- argc et argv
- Analyser les options
- getopt
- Construire un outil CLI