Activité 3: Paramètres en Ligne de Commande

Ce document présente une activité pratique sur les paramètres en ligne de commande en langage C. Il s'agit d'un exercice qui teste la compréhension de la gestion des arguments passés à un programme, la conversion de chaînes de caractères en nombres, ainsi que la manipulation des chaînes pour effectuer des calculs simples.

Activité 3 : Paramètres en Ligne de Commande

Cette activité demande d'explorer comment un programme en C peut recevoir des paramètres via la ligne de commande, les afficher, les convertir en nombres, et enfin réaliser un traitement sur une chaîne de caractères passée en argument.

Exemple d'affichage des paramètres passés au programme

On demande d'afficher tous les paramètres passés au programme, en commençant par le nom de l'exécutable.

Le programme utilise les arguments de la fonction main :

• argc : nombre total d'arguments (incluant le nom de l'exécutable)
• argv : tableau de chaînes de caractères contenant ces arguments, avec argv[0] le nom de la commande

Le code suivant réalise cet affichage :

#include <stdio.h>

// main(int argc, char *argv[])
// argc = nombre d'arguments sur la ligne (nom de l'executable compris)
// argv = tableau de chaines de car. qui contient dans la case 0 le
// nom de la commande et dans les autres les arguments de la commande
// RETOURNE : 0 en cas d'execution normale

int main(int argc, char *argv[])
{
  int nb;

  printf("les %d parametres de la commande %s sont :\n", argc-1, argv[0]);

  nb = 1;
  while(nb < argc){
    printf("\t%s\n",argv[nb]);
    nb++;
  }

  return 0;
}

Exemple d'exécution :

> ./test 1 15.3 bonjour A -39
les 5 parametres de la commande ./test sont :
        1
        15.3
        bonjour
        A
        -39

Conclusion : Le programme affiche correctement tous les paramètres passés, en ignorant le nom de la commande dans le comptage mais en l'affichant dans le message.

Conversion des paramètres en chiffres

On demande ici de convertir un paramètre passé en ligne de commande en un nombre entier, puis de calculer la somme des premiers entiers jusqu'à ce nombre.

Il faut :

• Vérifier que le nombre d'arguments est correct (ici, exactement 2 : le nom du programme et un entier)
• Convertir la chaîne de caractères en entier avec atoi
• Gérer le cas où la conversion donne 0, ce qui peut signifier une erreur ou une entrée nulle
• Calculer la somme des entiers de 0 à n

Le code complet est :

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

int main(int argc, char *argv[])
{
  int somme, n_premiers_entiers, indice ;

  if(argc != 2){
    printf("usage : somme N\n");
    exit(1);
  }

  n_premiers_entiers = atoi(argv[1]);
  if(n_premiers_entiers == 0){
    printf("vous n'avez pas entre un chiffre ou vous avez entre 0\n");
    exit(1);
  }

  printf("la somme des %d premiers entiers est ", n_premiers_entiers);

  indice = 0;
  somme = 0;
  while(indice <= n_premiers_entiers){
    somme += indice;
    indice++;
  }
  printf("%d\n", somme);

  return 0;
}

Exemples d'exécution :

• ./test 5 affiche la somme des 5 premiers entiers est 15
• ./test a affiche vous n'avez pas entre un chiffre ou vous avez entre 0
• ./test 3 4 affiche usage : somme N car trop d'arguments
• ./test affiche usage : somme N car pas d'argument
• ./test 0 affiche vous n'avez pas entre un chiffre ou vous avez entre 0
• ./test 3 affiche la somme des 3 premiers entiers est 6

Conclusion : Le programme vérifie correctement le nombre d'arguments, convertit la chaîne en entier, gère les erreurs, puis calcule la somme demandée.

Programme pour compter le nombre de lettres d'un mot passé en paramètre

La consigne est d'écrire un programme qui compte le nombre de lettres du mot donné en argument sur la ligne de commande.

Il faut :

• Vérifier que le nombre d'arguments est exactement 2 (nom du programme + mot)
• Parcourir la chaîne de caractères argv[1] jusqu'au caractère nul '\0'
• Compter le nombre de caractères rencontrés
• Afficher le résultat

Le code proposé est :

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

int main(int argc, char *argv[])
{
  int indice;

  if(argc != 2){
    printf("erreur");
    exit(1);
  }

  indice = 0;
  while(argv[1][indice] != '\0'){
    indice++;
  }

  printf("le mot %s contient %d lettres\n", argv[1], indice);

  return 0;
}

Exemples d'exécution :

• ./compte_lettre_mots abracadabra affiche le mot abracadabra contient 11 lettres
• ./compte_lettre_mots abricot affiche le mot abricot contient 7 lettres
• ./compte_lettre_mots zoo affiche le mot zoo contient 3 lettres
• ./compte_lettre_mots ce affiche le mot ce contient 2 lettres
• ./compte_lettre_mots a affiche le mot a contient 1 lettres

Conclusion : Le programme compte correctement le nombre de caractères d'une chaîne passée en argument.

Méthode : techniques récompensées et erreurs à éviter

• Vérification rigoureuse du nombre d'arguments : Toujours vérifier que le nombre d'arguments reçus correspond à ce qui est attendu avant de poursuivre le traitement. Cela évite des erreurs d'accès mémoire et des comportements indéfinis.
• Utilisation correcte des fonctions de conversion : Pour convertir une chaîne en nombre, utiliser les fonctions standard atoi, atol ou atof selon le type attendu. Toujours vérifier le résultat pour détecter une conversion invalide (par exemple, 0 peut signifier une erreur).
• Parcours des chaînes de caractères : Pour compter la longueur d'une chaîne, parcourir la chaîne caractère par caractère jusqu'au caractère nul '\0'. Ne pas dépasser la taille allouée.
• Affichage clair et informatif : Les messages doivent indiquer clairement ce qui est attendu en cas d'erreur (usage) ou le résultat obtenu.
• Gestion des erreurs : En cas d'erreur, utiliser exit(1) pour terminer proprement le programme.
• Respect des conventions du sujet : Utiliser les noms de variables et la structure du code tels que définis dans le sujet, même si d'autres conventions sont possibles.

Les erreurs pénalisées sont :

• Ne pas vérifier le nombre d'arguments
• Ne pas vérifier la validité de la conversion de chaîne en nombre
• Accéder à des indices hors limites dans argv ou dans les chaînes
• Omettre le caractère nul de fin de chaîne lors du parcours
• Messages d'erreur peu clairs ou absence de message