Explication de code svp :) Résolu

Question

Bonjour je suis passé en examen pour expliquer un code tiré au hasard x) ... malheureusement sa s'est mal passée j'ai pu expliaué les fonctions au dessus mais le main avec ces paramètres étaient plus difficile à expliquer. Si vous pouviez m'expliquer le main ligne par ligne par ligne x) pour savoir au moins ce que cela signifiait. J'ai aucune idée de la fonction du code.


#include <unistd.h>
 
void    ft_putchar(char c)
{
    write(1, &c, 1);
}
 
void    ft_putstr(char *str)
{
    int index;
 
    index = 0;
    while (str[index] != '\0')
    {
        ft_putchar(str[index]);
        index = index + 1;
    }
}
 
int     main(int argc, char **argv)
{
    int i;
    int j;
 
    i = 1;
    if (argc != 10)
    {
        ft_putstr("Erreur
");
        return (0);
    }
    while (i < 10)
    {
        j = 0;
        while (j < 9)
        {
            ft_putchar(argv[i][j]);
            ft_putchar(' ');
            j = j + 1;
        }
        ft_putchar('
');
        i = i + 1;
    }
    return (0);
}

Merci :)

Pierre1310 · Answer

Salut,

Mets dans des balises "C" stp.

nagaD.scar · Answer

Salut, 

en gros ce code va ecrire dans un fichier le contenu de argv, si argc à une valeur de 10 . (donc 9 arguments)

Ce qui est bizarre c'est qu'il faut que argv soit un tableau minimum de 10*9 (sinon ca ira lire dans la mémoire avec des chances de planter). 

après write(1, &c, 1); m'étonne car on donne un id de fichier ouvert fixe (1) ... c'est peu être un trick que je ne connais pas mais bon. 

naga

paly2 · Answer

Ce programme écrit, comme l'a dit nagaD.scar, les 9 premiers caractères des 9 premiers arguments du programme.

Cependant on observe plusieurs problèmes majeurs dans le programme (je ne sais pas s'il faisait partie de l'exercice de les décler ;-) ), qui en font un code de très mauvaise qualité.

1. Le message d'erreur correspondant au nombre de paramètres n'est pas clair. Il ne dit pas quelle est l'erreur.

2. La ligne suivante, on observe un code de retour 0 pour une erreur (il devrait être 1, ou, mieux, EXIT_FAILURE).

2. Il n'y a pas du tout de vérification que les arguments du programme font au moins 9 caractères. Il faut absolument en mettre une.

3. Aucune vérification d'erreur non plus pour l'appel-système write.

4. Des équivalents aux fonctions ft_putstr et ft_putchar existent déjà dans la bibliothèque standard (printf, par exemple, remplace les deux). La création de ces fonctions, en plus de complexifier le programme pour rien, le rend non-portable (le header <unistd.h> n'existe que sous les systèmes UNIX).

5. Et beaucoup de questions de style, dont

index = index + 1;

qui devrait plutôt être écrit

index++;

.

Sinon, le programme expliqué ligne par ligne:

#include <unistd.h> // On inclue le header <unistd.h> pour la fonction write()
 
void    ft_putchar(char c) // Définition de la fonction ft_putchar, qui affiche un caractère
{
    write(1, &c, 1); // On écrit le caractère sur le flux de sortie standard (de file descriptor 1).
}
 
void    ft_putstr(char *str) // Définition de la fonction ft_putchar, qui affiche une chaîne de caractères
{
    int index; // Définition de la variable index
 
    index = 0; // Initialisation de la variable index à 0
    while (str[index] != '\0') // Tant que nous ne tombons pas sur le caractère \0 (qui indique la fin d'une chaîne de caractères)...
    {
        ft_putchar(str[index]); // On affiche le caractère à l'index
        index = index + 1; // On incrémente l'index pour qu'il corresponde au caractère suivant
    }
}
 
int     main(int argc, char **argv) // Définition de la fonction main
{
    int i; // Définition de la variable i
    int j; // Définition de la variable j
 
    i = 1; // Initialisation de la variable i à 1
    if (argc != 10) // S'il n'y a pas 10 arguments (note: le premier correspond à l'emplacement du programme, ou plus précisément à la commande qui a été écrite dans le shell pour l'exécuter)
    {
        ft_putstr("Erreur\n"); // On affiche "Erreur"
        return (0); // On arrête le programme et on retourne un code de... succès (oui, c'est très incohérent) !
    }
    while (i < 10) // Tant que i est inférieur à 10 (notons au i correspond à l'argument actuel)
    {
        j = 0; // On initialise j à 0
        while (j < 9) // Tant que ju est inférieur à 9 (notons que j correspond au caractère actuel)
        {
            ft_putchar(argv[i][j]); // on affiche le caractère
            ft_putchar(' '); // on affiche un espace
            j = j + 1; // on incrémente j
        }
        ft_putchar('\n'); // On affiche un retour à la ligne
        i = i + 1; // On incrémente i
    }
    return (0); // On retourne 0 (code de succès, fin du programme)
}

La curiosité est une excellente qualité !

Explication de code svp :)

3 réponses

Votre réponse

Discussions similaires