ENIB LANG-C 05_Strings - Chaînes de caractères

{} Séquences de caractères

L'usage commun d'une chaîne de caractères consiste à représenter et manipuler un texte quelconque.
Celui-ci peut être de longueur nulle, ne contenir qu'un seul caractère, représenter un mot, ou bien une phrase avec de la ponctuation et pourquoi pas un paragraphe, une page ou encore un document complet.
Cela marque une différence fondamentale avec les types du langage C que nous connaissons : une chaîne de caractère n'occupe probablement pas le même nombre d'octets en mémoire selon la valeur qu'elle a.
Il ne s'agit donc pas d'un type de base, à la taille fixe sur une plateforme d'exécution, mais au contraire d'un type élaboré pour représenter une séquence d'information de longueur variable.

{} Le type des caractères

Le type char n'est rien d'autre qu'un petit entier tenant sur un seul octet.
Selon la plateforme d'exécution, il peut être implicitement signé ou non-signé.
Si nous souhaitions l'utiliser pour des calculs arithmétiques (ce qui est possible), il nous faudrait probablement le qualifier de signed ou unsigned afin de contrôler précisément ses limites (voir ce chapitre).
Un usage plus courant de ce type consiste à interpréter sa valeur numérique comme un caractère (d'où son nom).
La conversion entre cette valeur numérique et un caractère n'est qu'affaire de convention.
Il existe à ce propos une table de conversion unanimement reconnue : la table ASCII.
(https://en.cppreference.com/w/c/language/ascii)
Un périphérique spécialisé (imprimante, écran...) qui reçoit une telle valeur numérique tenant sur un octet doit réagir en produisant l'effet approprié.
Si le code reçu représente un caractère imprimable, alors un dessin qui évoque aux êtres humains une lettre, un chiffre ou de la ponctuation (éventuellement vide si c'est une espace) sera produit.
Il existe également des codes représentant des caractères de contrôle, c'est-à-dire qui provoquent la modification de la position d'écriture (changer de ligne, avancer jusqu'au prochain point de tabulation, etc).

Voici, à titre d'exemple, l'effet produit par la réception de tels caractères dans le terminal :

...
{
  char txt[10]={72, 105, 44, 9, 69, 78, 73, 66, 33, 10}; // saisie des codes ASCII
  for(int i=0; i<10; ++i)
  {
    printf("%c", txt[i]);  // Hi, ENIB!
  }
  for(int i=0; i<10; ++i)
  {
    printf("%d ", txt[i]); // 72 105 44 9 69 78 73 66 33 10
  }

Remarquez que le format "%c" utilisé dans printf() transmet tel quel le code numérique du caractère vers le terminal (vérifiez avec la table ASCII).
Le format "%d" traduit au contraire la valeur entière de ce code numérique en une séquence de codes dont la réception par le terminal provoque l'affichage de caractères ayant l'apparence de chiffres.
(https://en.cppreference.com/w/c/io/fprintf)

{} Les caractères litéraux

{} Les catégories de caractères

Il est mentionné plus haut que dans la table ASCII existent des caractères imprimables et des caractères de contrôle.
Des fonctions standards permettent de les distinguer.
(https://en.cppreference.com/w/c/string/byte/isprint)
(https://en.cppreference.com/w/c/string/byte/iscntrl)
Comme indiqué sur ces pages de documentation, le fichier d'en-tête standard

<ctype.h>

propose encore bien d'autres fonctions pour distinguer plus finement ces catégories.

...
{
  char txt[7]={'1', ' ', 'M', 'o', 'R', 'e', '?'};
  for(int i=0; i<7; ++i)
  {
    if(isdigit(txt[i]))
    {
      printf("<%c>", txt[i]);          // <1>
    }
  }
  for(int i=0; i<7; ++i)
  {
    if(ispunct(txt[i]))
    {
      printf("<%c>", txt[i]);          // <?>
    }
  }
  for(int i=0; i<7; ++i)
  {
    if(isupper(txt[i]))
    {
      printf("<%c>", tolower(txt[i])); // <m><r>
    }
  }
  ...
}

Remarquez également que les fonctions toupper() et tolower() permettent de basculer les caractères alphabétiques vers les majuscules ou les minuscules.
En observant la table ASCII et la documentation de ces fonctions, vous constaterez que certaines catégories de caractères occupent des codes numériques contigus (pas toutes).
Cela donne parfois l'opportunité, sur les problèmes qui le méritent, de déduire certains caractères par des relations arithmétiques.

...
{
  char txt[12]={'B', 'h', 'e', ' ', 'F', 'r', 'p', 'e', 'r', 'g', '!', '\n'};
  for(int i=0; i<12; ++i)
  {
    char c=txt[i];
    if(isalpha(c))
    {
      int first=isupper(c) ? 'A' : 'a';
      c=(char)(first+((c-first)+13)%26);
    }
    printf("%c", c); // Our Secret!
  }
  ...
}

Cet exemple exploite cette propriété en transformant l'écart entre un caractère alphabétique et la lettre 'A' ou 'a' selon l'algorithme ROT13✍ (simulez-le à la main en vous aidant de la table ASCII).
Nous renforçons ainsi la mise en évidence du fait que les caractères littéraux ne sont rien d'autre que des valeurs entières tenant sur un octet.

{} Le zéro terminal

Pour une raison de facilité, les exemples précédents stockaient les caractères dans un tableau afin de les énumérer dans une boucle.
L'énumération de ces caractères pour produire un affichage revient finalement à afficher une chaîne de caractères.
Nous pouvons donc assimiler un tableau de caractères à une chaîne.
L'inconvénient de cette solution vient du fait qu'il faut connaître à l'avance le nombre d'éléments à énumérer dans ce tableau : ce nombre varie selon la longueur du texte à représenter.

Une convention unanimement adoptée consiste à utiliser un caractère de contrôle spécial pour indiquer que la chaîne est terminée.
Ainsi, l'énumération des caractères d'une chaîne n'est pas simplement conditionnée par un compteur que l'on confronte à une limite préalablement déterminée, mais par les caractères découverts lors de cette énumération.
Le caractère de contrôle en question est dénommé le caractère nul (ou zéro terminal), il a le code ASCII 0 et est usuellement représenté de manière littérale par '\0'.

...
{
  char txt[]={'H', 'e', 'l', 'l', 'o', ',', ' ', 'E', 'N', 'I', 'B', '!', '\n', '\0'};
  for(int i=0; txt[i]; ++i)
  {
    printf("%c", txt[i]); // Hello, ENIB!
  }
  ...
}

Selon cette convention, la boucle d'énumération des caractères s'arrête dès qu'un caractère nul est rencontré ; il n'est donc pas nécessaire ici de déterminer explicitement le nombre d'éléments du tableau.
Cette chaîne occupe un octet de plus que le nombre de ses caractères utiles puisqu'on y ajoute le caractère nul.
Cette convention impose qu'une telle chaîne ne peut pas contenir '\0' parmi ses caractères utiles car tous les éventuels caractères qui le suivraient seraient forcément ignorés.
Remarquez que lors de l'affichage d'une chaîne, le caractère nul n'est pas envoyé au terminal : la boucle est immédiatement terminée lors de sa détection✍.

L'usage du caractère de fin est tellement commun que bon nombre de fonctions qui traitent des chaînes en présupposent la présence et reposent sur sa détection.
C'est le cas par exemple de la fonction printf() qui utilise le format "%s" pour énumérer automatiquement les caractères d'une chaîne jusqu'au zéro terminal et les afficher.

...
{
  char txt[]={'H', 'e', 'l', 'l', 'o', ',', ' ', 'E', 'N', 'I', 'B', '!', '\0'};
  printf("<%s>\n", txt); } // <Hello, ENIB!>
  ...
}

Le type attendu est const char *, ce qui est cohérent avec le fait que l'évaluation du nom d'un tableau fournit un pointeur sur son premier élément.
(https://en.cppreference.com/w/c/io/fprintf)

{} Initialisation des chaînes de caractères

La spécification de chaque élément du tableau sous la forme de caractères littéraux est certes plus aisée que l'usage des codes ASCII mais est encore loin d'être naturelle.
Bien qu'il n'existe pas vraiment de type spécifiquement dédié à leur représentation, les chaînes terminées par un caractère nul sont d'un usage tellement courant que le langage C offre des facilités pour les initialiser avec des constantes littérales.

{} Les chaînes littérales

La notation utilisée pour spécifier la chaîne de format de la fonction printf() n'est rien d'autre qu'une chaîne littérale.
Nous la reconnaissons au fait qu'elle encadre un texte par une paire de symboles " (guillemets).
Il s'agit essentiellement d'une facilité d'écriture pour énumérer un à un les caractères littéraux de ce texte en y ajoutant le zéro terminal comme nous le faisions dans les exemples de cette section.

...
{
  char txt1[]={'H', 'e', 'l', 'l', 'o', ',', ' ', 'E', 'N', 'I', 'B', '!', '\0'};
  char txt2[]="Hello, ENIB!";
  printf("<%s><%s>\n",txt1,txt2); // <Hello, ENIB!><Hello, ENIB!>
  ...
}

Les deux formes d'initialisation des chaînes txt1 et txt2 sont strictement équivalentes : les guillemets se substituent à la liste d'initialisation du tableau.
Les octets qui constituent ces deux chaînes sont bien stockés dans la pile comme tout tableau de classe de stockage automatique.
Notez que cette facilité d'écriture n'existe que pour les tableaux de char ; pour les autres types, la liste d'initialisation est le seul moyen de spécifier le contenu initial du tableau.
De la même façon que la liste d'initialisation ne peut pas servir à affecter un tableau après sa déclaration, une chaîne littérale ne peut être affectée à un tableau de char qu'au moment de sa déclaration.

Puisque les chaînes littérales facilitent la saisie, il peut être tentant de saisir de longs textes.
Seulement, pour préserver la lisibilité du code source nous n'avons pas intérêt à en allonger les lignes exagérément.
Pour encore plus de facilité de saisie, le compilateur considère plusieurs chaînes littérales qui se suivent directement comme n'en formant qu'une seule.

...
{
  char txt1[]="Only" " one " "string";
  char txt2[]="This is a very long text that would hardly fit the width of"
              " my text editor! Fortunately, the designers of C thought about "
              "every detail.";
  printf("<%s><%s>\n", txt1, txt2); // <Only one string><This is a very long text ... every detail.>
  ...
}

Le zéro terminal n'est placé qu'à la fin de la dernière des chaînes littérales successives.

{} Affectation à un pointeur

Le chapitre sur les pointeurs et les tableaux indiquait qu'il existe une conversion implicite donnant un pointeur à partir du nom d'un tableau, et que ce pointeur désigne l'adresse du premier élément de ce tableau.
Il est donc correct d'initialiser un pointeur sur un char à partir d'un tableau de char représentant une chaîne.

...
{
  char txt[]="Hello, ENIB!";
  char *split=txt+5;
  for(char *p=txt; p<split; ++p)
  {
    *p=(char)toupper(*p);           // passer les cinq premières lettres en majuscule
  }
  *(split++)='\0';                  // marquer la fin juste après puis avancer
  printf("<%s><%s>\n", txt, split); // <HELLO>< ENIB!>
  ...
}

À titre de révision, cet exemple utilise l'arithmétique des pointeurs pour modifier le contenu du tableau.
Remarquez l'usage de l'opérateur de post-incrémentation qui incrémente le pointeur seulement après en avoir extrait l'adresse qui servira au déréférencement.
En plaçant un caractère nul à la place de la virgule nous avons séparé la chaîne initiale en deux.
La fonction printf() utilise tout aussi bien le nom d'un tableau qu'un pointeur pour afficher des chaînes.

Il est également possible d'affecter un pointeur depuis une chaîne littérale, mais cette opération n'a plus du tout la même signification que précédemment !
Les chaînes littérales qui ne servent pas à initialiser un tableau de char sont stockées dans une zone mémoire constante.
Leur valeur est l'adresse de leur premier caractère et doit être uniquement affectée à un pointeur vers des caractères constants✍.
En effet, une tentative d'écriture à cette adresse provoquerait un plantage du programme sur la plupart des plateformes d'exécution.

...
{
  const char *txt="Hello, ENIB!";
  printf("<%s><%s>\n", txt, txt+7); // <Hello, ENIB!><ENIB!>
  ...
}

Dans ces conditions, nous ne pouvons que consulter ces chaînes littérales.
Remarquez que les chaînes de format que nous utilisons pour les invocations de printf() dans nos exemples sont justement des chaînes littérales placées dans une zone mémoire constante ; elle sont affectées au premier paramètre formel de cette fonction qui est bien de type const char *.
(https://en.cppreference.com/w/c/io/fprintf)

Puisque les chaînes littérales ont été initialement présentées comme une facilité nous évitant d'avoir à saisir un à un les caractères littéraux d'un tableau, il est légitime de s'interroger sur la validité de cette équivalence lorsqu'on à affaire à la mémoire constante.

...
{
  char txt1[]="correct";
  char txt2[]={'c', 'o', 'r', 'r', 'e', 'c', 't', '\0'};
  const char *txt3="correct";
  // const char *txt4={'i', 'n', 'c', 'o', 'r', 'r', 'e', 'c', 't', '\0'}; // INCORRECT
  ...
}

L'échec à l'initialisation de txt4 montre que l'équivalence n'est pas valide dans ce cas : les chaînes littérales sont vraiment traitées comme des cas à part !

{} Les fonctions de manipulation de chaînes

L'usage de chaînes de caractères à zéro terminal est tellement commun que le fichier d'en-tête standard

<string.h>

est justement dédié à la déclaration de fonctions spécialisées dans leur manipulation.
Il s'agit d'un ensemble très vaste ; nous ne présentons ici que les plus courantes.
(https://en.cppreference.com/w/c/string/byte)

{} Longueur d'une chaîne

La longueur d'une chaîne se définit simplement par le nombre de caractères qui précèdent le zéro terminal✍.
Le nombre minimal d'octets nécessaire à la mémorisation d'une chaîne correspond donc à sa longueur plus un : un octet par caractère plus le zéro terminal.

La fonction standard strlen() est dédiée à ce propos.
(https://en.cppreference.com/w/c/string/byte/strlen)
Elle compte les caractères à partir de celui qui lui est transmis par pointeur jusqu'à rencontrer le caractère nul (qui n'est pas compté).

...
{
  char str1[]="first string";
  char str2[100]="second string";
  const char *str3="third string";
  printf("<%s> %d %d\n", str1,   (int)strlen(str1),   (int)sizeof(str1));   // <first string> 12 13
  printf("<%s> %d %d\n", str2,   (int)strlen(str2),   (int)sizeof(str2));   // <second string> 13 100
  printf("<%s> %d %d\n", str3,   (int)strlen(str3),   (int)sizeof(str3));   // <third string> 12 8
  printf("<%s> %d %d\n", str2+7, (int)strlen(str2+7), (int)sizeof(str2+7)); // <string> 6 8
  ...
}

Remarquez bien sur cet exemple les différences entre la fonction strlen() et l'opérateur sizeof : ce sont des sources de confusion fréquentes.
Sur str1 nous constatons en particulier que l'initialisation du tableau par la chaîne littérale ajoute implicitement le zéro terminal : sa taille fait un octet de plus que la longueur de la chaîne.
Toutefois, comme constaté sur str2, rien n'empêche de réserver un tableau plus grand que ce qui est nécessaire pour la chaîne.
Sur str3 nous constatons que l'opérateur sizeof appliqué à un pointeur donne la taille du pointeur lui-même et non la taille de ce qui est pointé✍.
Cela se remarque aussi sur str2+7 qui est considéré par l'opérateur sizeof comme un pointeur alors que str2 est considéré comme le tableau dans sa globalité.
Les cas de cet exemple mettent en évidence le fait que la fonction strlen() est un procédé dynamique qui compte un à un les caractères découverts à l'exécution alors que l'opérateur sizeof fournit une valeur déjà connue du compilateur par l'analyse préalable du type concerné.
Notez enfin que le type du résultat de la fonction strlen() est size_t, tout comme le résultat de l'opérateur sizeof✍, et nécessite donc un cast pour être considéré comme un simple entier.

{} Comparaison de chaînes

Les chaînes de caractères n'étant pas des types de base, il n'existe aucun opérateur du langage sachant directement comparer leurs contenus (comme c'est le cas pour des entiers ou des réels par exemple).
Cependant, puisque les chaînes sont manipulées par des variables de type pointeur ou tableau, la comparaison de ces variables est autorisée et se contente de comparer les adresses et non les contenus, ce qui est extrêmement trompeur !
Il s'agit en effet d'arithmétique des pointeurs.

...
{
  char str1[]="same string";
  const char *str2="same string";
  char *str3=str1;
  if(str1!=str2)
  {
    printf("str1!=str2\n"); // str1!=str2
  }
  if(str1==str3)
  {
    printf("str1==str3\n"); // str1==str3
  }
  ...
}

Ici str1 et str2 désignent bien des contenus identiques mais qui sont stockés à des adresses différentes.
De toute évidence str3 est égale à str1 puisqu'elle a été initialisée explicitement pour désigner la même adresse (celle du premier élément de str1).

La comparaison des contenus des chaînes est confiée à la fonction standard strcmp().
(https://en.cppreference.com/w/c/string/byte/strcmp)
Elle n'effectue pas qu'un simple test d'équivalence des contenus mais une comparaison lexicographique pour établir une relation d'ordre.
Il s'agit de comparer un à un les caractères en même position dans chacune des deux chaînes en partant du début.
Si le code ASCII de l'un précède l'autre, alors la valeur de sa chaîne est immédiatement considérée inférieure à celle de l'autre.
Tant que les caractères sont identiques, la comparaison se poursuit.
Si les comparaisons sont identiques jusqu'au zéro terminal des deux chaînes, c'est qu'elles ont des contenus identiques.
Si l'une d'elles est terminée avant l'autre, bien que commençant par des séquences identiques, alors sa valeur est considérée comme inférieure à celle de l'autre.
En résumé : pensez simplement à la façon dont sont ordonnés les mots dans un dictionnaire.

La fonction strcmp() indique par un entier le résultat de la comparaison des deux chaînes qu'elle reçoit en paramètres.
Cet entier vaut zéro si les chaînes sont considérées identiques, il est négatif si la première est considérée inférieure à la seconde ou positif dans le cas contraire.

...
{
  char str1[]="shorter", str2[]="same string";
  const char *str3="same string", *str4="same string but longer";
  printf("%d %d %d\n",              // 7 0 -32
         strcmp(str1, str2),
         strcmp(str2, str3),
         strcmp(str3, str4));
  if(strcmp(str2, str3)==0)
  {
    printf("str2 same as str3\n");  // str2 same as str3
  }
  ...
}

Remarquez que str1 est plus courte que str2 alors que leur comparaison désigne str1 comme supérieure à str2 (résultat positif).
Le résultat nul de la comparaison de str2 et str3 indique que ces deux chaînes ont un contenu identique ; elles sont pourtant stockées à des emplacements distincts (voir l'exemple précédent).
Les chaînes str3 et str4 sont identiques jusqu'à la fin de la première ; elle est donc inférieure (résultat négatif) à la seconde.
La documentation de la fonction strcmp() précise que la valeur exacte du résultat importe peu : seuls le signe et la nullité ont du sens.
La dernière comparaison utilisée comme condition d'une alternative est une construction très courante.

La fonction strncmp() est une variante de la précédente qui limite la comparaison à la longueur maximale indiquée en paramètre ; elle sert notamment à déterminer si une chaîne commence par une autre.
(https://en.cppreference.com/w/c/string/byte/strncmp)

{} Recherche dans une chaîne

{} Recopie d'une chaîne

Puisque les chaînes de caractères ne sont pas des types de base, il n'existe aucun opérateur du langage sachant directement en recopier le contenu ; comme vu dans ce chapitre, les tableaux ne peuvent pas être affectés et l'affectation de pointeurs affecte l'adresse mais pas le contenu d'une chaîne.
Recopier une chaîne revient alors à énumérer les caractères d'une chaîne source pour les recopier un à un vers une chaîne de destination, jusqu'à rencontrer le zéro terminal qui est lui même recopié afin de terminer la chaîne de destination.
Bien entendu, cette dernière doit être modifiable et être préalablement dimensionnée pour être au moins aussi grande que la source.

La fonction standard strcpy() est dédiée à ce propos.
(https://en.cppreference.com/w/c/string/byte/strcpy)

...
{
  const char *str1="first string";
  char str2[100];         // très largement dimensionné
  strcpy(str2, str1);
  printf("<%s>\n", str2); // <first string>
  strcpy(str2+6, str1);
  printf("<%s>\n", str2); // <first first string>
  ...
}

Le tableau str2 a initialement un contenu indéterminé mais la fonction strcpy() vient renseigner ses premiers octets avec ceux de la chaîne désignée par str1.
Si nous savons ce que nous faisons, la destination de la copie ne doit pas forcément coïncider avec le début du tableau.
Il convient toutefois d'être très prudent car ni le compilateur ni la fonction strcpy() ne sont en mesure de déterminer si l'espace réservé pour la destination est suffisant (ici nous avons surdimensionné str2 en prévision).

La fonction strncpy() est une variante de la précédente qui limite la recopie au nombre maximal d'octets indiqué en paramètre.
L'écriture du zéro terminal n'est pas systématique (c'est une source d'erreur bien connue !) ; consultez très attentivement la documentation avant de vous en servir.
(https://en.cppreference.com/w/c/string/byte/strncpy)

Une variante de la recopie consiste en la concaténation : il s'agit de recopier une chaîne à la suite d'une autre.
La fonction standard strcat() se charge de cette opération.
(https://en.cppreference.com/w/c/string/byte/strcat)

...
{
  char str1[100]="one way";
  char str2[100]="another way";
  strcat(str1, " to concatenate");
  strcpy(str2+strlen(str2), " to do the same");
  printf("<%s><%s>\n", str1, str2); // <one way to concatenate><another way to do the same>
  ...
}

Cet exemple illustre le fait que la concaténation est très similaire à la recopie.
La même prudence est de mise concernant l'espace réservé pour la chaîne de destination.

La fonction strncat() est une variante de la précédente qui limite la recopie au nombre maximal de caractères indiqué en paramètre.
Contrairement à strncpy(), l'écriture du zéro terminal est systématique.
(https://en.cppreference.com/w/c/string/byte/strncat)

Il est très important de retenir que les fonctions de recopie ou de concaténation de chaînes ne doivent être utilisées qu'en s'assurant du fait que la chaîne de destination utilise un espace de stockage suffisamment grand pour accueillir tous les caractères de l'opération et le zéro terminal.
Sans cette précaution, les octets excédentaires écraseront probablement d'autres données, ce qui conduira à un comportement indéterminé du programme difficilement identifiable au débogueur.
Un prochain chapitre présentera l'allocation dynamique de mémoire qui peut être utilisée avantageusement pour réserver un tel espace à la demande selon les conditions d'exécution du programme.

{} La ligne de commande

Jusqu'à maintenant, nos programmes ne reçoivent aucune consigne quant à leur fonctionnement.
Leur seul paramétrage repose sur un ensemble de valeurs inscrites dans le code source et nécessite une nouvelle fabrication du programme exécutable à chaque modification de l'une d'elles.

Nous sommes déjà familiers de programmes auxquels nous passons des consignes lorsque nous les invoquons : le compilateur reçoit des options et le nom du fichier à compiler, l'éditeur de texte reçoit le nom du fichier à éditer...
Toutes ces informations sont passées sur la ligne de commande.
Ainsi, si nous réalisons un programme exécutable nommé prog, la commande : $ ./prog there are some options ↵ provoque l'exécution de notre programme avec une ligne de commande constituée de son nom et des quatre mots suivants.
La ligne de commande est une séquence de mots représentés chacun par une chaîne de caractères ; il y en a cinq sur cet exemple.

Le code source d'un programme peut y accéder en utilisant une nouvelle formulation pour le prototype de la fonction principale main().
(https://en.cppreference.com/w/c/language/main_function)

int
main(int argc,    // argument counter : le nombre de mots de la ligne de commande
     char **argv) // argument values : le tableau des mots de la ligne de commande
{
  // ...
  return 0;
}

Comme pour toute autre fonction, les noms des paramètres peuvent être choisis librement.
Toutefois, tous les programmeurs utilisent les noms argc et argv pour nommer les paramètres de la fonction main().
Cette habitude permet de les reconnaître sans la moindre ambiguïté.
Les types de ces paramètres sont en revanche imposés ; néanmoins, il arrive que le second soit formulé char *argv[].
En effet, cette section précise qu'un tableau passé en paramètre n'est rien d'autre qu'un pointeur : la notation à base de crochets est, dans ces conditions, strictement équivalente à celle utilisant l'étoile✍.
Le paramètre argv est donc un tableau dont chaque élément est une chaîne de caractères.
Ce tableau contient argc éléments correspondant chacun à un mot de la ligne de commande et un dernier élément qui est un pointeur nul.
Tout se passe donc comme si, dans le cas présent, la fonction main() était invoquée de cette façon :

...
{
  char a0[]="./prog", a1[]="there", a2[]="are", a3[]="some", a4[]="options";
  char *commandLine[]={a0, a1, a2, a3, a4, NULL};
  int result=main(5, commandLine);
  ...
}

Bien entendu, cela n'est qu'illustratif : nous ne pouvons rien supposer quant aux détails effectifs de l'invocation de la fonction main() par le système d'exploitation.

Voici un programme typique qui énumère les arguments de sa ligne de commande.
L'affichage qu'il produit correspond à la ligne de commande évoquée précédemment.

#include <stdio.h>

int
main(int argc,
     char **argv)
{
  for(int i=0; i<argc; ++i)                  // argv[0]=<./prog>
  {                                          // argv[1]=<there>
    printf("argv[%d]=<%s>\n", i, argv[i]);   // argv[2]=<are>
  }                                          // argv[3]=<some>
  return 0;                                  // argv[4]=<options>
}

Un usage plus utile de ces arguments consisterait à analyser leur contenu pour conditionner l'exécution de différentes parties d'un programme.
Il est notamment possible d'extraire des valeurs numériques de ces chaînes de caractères en utilisant les fonctions atoi() ou atof() déclarées dans le fichier d'en-tête standard

<stdlib.h>

.
(https://en.cppreference.com/w/c/string/byte/atoi)
(https://en.cppreference.com/w/c/string/byte/atof)
Toutefois, ces fonctions ne permettent pas de savoir si la chaîne analysée décrivait effectivement une valeur numérique.
Il est préférable d'utiliser à cette fin les fonctionnalités de formatage présentées dans cette section.

Complément : exemple d'utilisation de la ligne de commande