Forum Programmation.c Utiliser le terminal Linux pour compiler en C

Posté par  . Licence CC By‑SA.
Étiquettes : aucune
1
4
juin
2013

Bonjour, je dois réaliser un programme en C sur Linux. Je sais que pour compiler en utilisant le terminal, il faut passer par ces étapes là:

gcc -c exemple.c
gcc -o exemple exemple.o
./exemple

Le fichier .c que je compile doit ouvrir un fichier (fopen, …). Je fait donc un printf("Entrez le nom du fichier") dans mon programme. Cependant, je voudrai savoir s'il est possible, directement sur le terminal, de faire appel à mon fichier tout en passant l'argument, comme ceci : exemple nom_du_fichier_a_ouvrir.txt.

Merci pour votre aide.

  • # Les arguments

    Posté par  (site web personnel) . Évalué à 10. Dernière modification le 04 juin 2013 à 01:02.

    Oui c'est parfaitement possible.
    Pour cela il faut utiliser les arguments de la fonction main(). Petit exemple :

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

int main(int argc, char *argv[])
{
    int i;
    for(i = 0; i < argc; i++)
         printf("%d : %s\n", i, argv[i]);

    return EXIT_SUCCESS;
}

    Tu verras que argv contient l'ensemble des arguments sous forme de chaine de caractères (chaque case de la liste des chaines = un argument passé en paramètre, dans l'ordre)
    Il te suffit de tester l'argument 2 pour voir si c'est un nom de fichier valide et tu pourras l'utiliser sans problème. ;)

    • [^] # Re: Les arguments

      Posté par  (site web personnel) . Évalué à 0.

      l'argument 2

      Le 2ème argument, ou l'argument 1.
      Les codeurs comptent à partir de 0 ;-).

      Info pour ceux qui ne connaissent pas : argv[0] est le nom du programme appelant.

      • [^] # Re: Les arguments

        Posté par  . Évalué à 4.

        Info pour ceux qui ne connaissent pas : argv[0] est le nom du programme appelant.

        ou pas.

        • [^] # Re: Les arguments

          Posté par  . Évalué à 3. Dernière modification le 04 juin 2013 à 15:27.

          http://crasseux.com/books/ctutorial/argc-and-argv.html

          argv[0] représente la chaine utilisée pour appeler le programme et non le programma appelant.

          As you can see, the first argument (argv[0]) is the name by which the program was called, in this case gcc. Thus, there will always be at least one argument to a program, and argc will always be at least 1.

The following program accepts any number of command-line arguments and prints them out:

#include <stdio.h>

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

  printf ("This program was called with \"%s\".\n",argv[0]);

  if (argc > 1)
    {
      for (count = 1; count < argc; count++)
    {
      printf("argv[%d] = %s\n", count, argv[count]);
    }
    }
  else
    {
      printf("The command had no other arguments.\n");
    }

  return 0;
}

If you name your executable fubar, and call it with the command ./fubar a b c, it will print out the following text:

This program was called with "./fubar".
argv[1] = a
argv[2] = b
argv[3] = c

          • [^] # Re: Les arguments

            Posté par  (site web personnel) . Évalué à 0.

            argv[0] représente la chaine utilisée pour appeler le programme et non le programma appelant.

            Euh… La formulation n'était peut-être pas terrible (je n'ai pas dit "le nom du programme qui lance le programme"), mais sinon ça veut dire la même chose… Si il faut être plus précis : le nom du programme appelant main() (ce programme ayant été lancé par le kernel, avec parfois un autre point d'entrée du programme, genre mainCRTStartup() qui appartient bien au programme et qui appelle main() ).
            Mais la, on reste sur le tatillon… Et on parle de la même chose, juste le plaisir de causer.

            • [^] # Re: Les arguments

              Posté par  (site web personnel) . Évalué à 3.

              Bah non.

              $ cat t2.c 
#include <stdio.h>
#include <unistd.h>

int main(int argc, char **argv)
{
        printf("argv[0] = %s\n", argv[0]);
        sleep(30);
        return 0;
}
$ cat t.c 
#include <unistd.h>

int main(int argc, char *argv[], char *envp[])
{
        char *const blargv[] = {
                "\\_o< COIN! COIN!",
                NULL
        };
        execve("./t2", blargv, envp);
        return 42;
}
$ cc -o t t.c
$ cc -o t2 t2.c
krunch@chouffe:/tmp$ ./t &
[1] 13127
$ argv[0] = \_o< COIN! COIN!
ps x | grep COIN
13127 pts/11   S      0:00 \_o< COIN! COIN!
13135 pts/11   S+     0:00 grep COIN
$ pgrep -l t2
13127 t2
$ ps x | grep t2
13150 pts/11   S+     0:00 grep t2
$ pgrep -l COIN
$

              Après tu vas me dire que j'interprète mal tes propos volontairement mais c'est pas grave parce que j'ai appris à ignorer tes réponses.

              pertinent adj. Approprié : qui se rapporte exactement à ce dont il est question.

              • [^] # Re: Les arguments

                Posté par  . Évalué à 1. 

                $ cd troll
$ cat trollage_de_zenitram.c 
main(int ac, char**av)
{
    puts(*av);
}
$ gcc -o trollage_de_zenitram trollage_de_zenitram.c
$ $ ../troll/../troll/../troll/trollage_de_zenitram 
../troll/../troll/../troll/trollage_de_zenitram

                :)

                Please do not feed the trolls

              • [^] # Re: Les arguments

                Posté par  . Évalué à 2.

                Tu peux expliquer ou tu veux en venir ? Je ne comprends pas ce que tu cherches à prouver.

                • [^] # Re: Les arguments

                  Posté par  (site web personnel) . Évalué à 2.

                  il trafique argv[0] en le forçant à une autre valeur que le nom du programme lancé (j’essaye d'éviter une malcompréhension sur le mot :) ), pour me faire mentir.
                  C'est un hack, qui est pas disponible partout. Si ça l'amuse…

                  • [^] # Re: Les arguments

                    Posté par  . Évalué à 4.

                    Ça n'est pas un hack, on peut mettre ce qu'on veut dans le argv[0] en argument de execve(). Le fait d'y mettre le nom du programme est juste une convention qui est plus ou mois respectée, mais il y a des exceptions par exemple pour conditionner le fonctionnement d'un programme. Par exemple si on met un tiret avant le nom du shell dans argv[0] il se comporte differemment. ("A login shell is one whose first character of argument zero is a -, or one started with the --login option.")
                    Il y a aussi des situations réelles comme le shebang où le nom du programme tel qu'appelé ne se retrouve pas en argv[0] mais en argv[1]:

                    edelweiss:~$ cat print_args.c 
#include <stdio.h>
int main(int argc, char **argv)
{
    while (*argv)
        puts(*argv++);
    return 0;
}
edelweiss:~$ gcc -o print_args print_args.c 
edelweiss:~$ cat toto.sh 
#!/home/edelweiss/print_args
edelweiss:~$ ./toto.sh 
/home/edelweiss/print_args
./toto.sh

                    Bizarrement, bash cache ce mecanisme dans les scripts:

                    edelweiss:~$ cat toto2.sh 
#!/bin/bash
echo $0 $1
edelweiss:~$ ./toto2.sh 
./toto2.sh

            • [^] # Re: Les arguments

              Posté par  . Évalué à 4.

              Pour moi le programme appelant est le programme qui lance le programme. : dans une session interactive, le programme appelant sera le shell (bash, sh, csh selon les préférences). Peut-être n'est-ce pas ce que tu as voulu dire, mais c'est ce que j'ai compris à ta lecture.

              Et dans le texte que je cite, je traduis " is the name by which the program was called" par "est le nom par lequel le programme a été appelé." ce qui est différent du "nom de l'appelant" …

              Je ne t'apprendrais rien, mais pour ceux qui ne savent pas, c'est une astuce qui permet d'avoir un même exécutable qui effectuera des choses plus ou moins différentes en fonction du nom par lequel on l'a appelé (busybox fonctionne comme ça : plein de liens sur le même exécutable).

              • [^] # Re: Les arguments

                Posté par  . Évalué à 4.

                Quelle mauvaise foi ! Si Tatie Josianne compose ton numéro de téléphone, qu'il se mette à sonner, que ton tympan actionne ton étrier qui actionne ton limaçon qui envoie des signaux électriques dans le nerf vestibulaire à ton cerveau, c'est donc toi qui appelle du fait que Tatie elle a pas branlé grand chose par rapport à tout le bordel qui s'est déroulé dans ton oreille interne.

  • # Makefile

    Posté par  . Évalué à 1. 

    gcc -c exemple.c
gcc -o exemple exemple.o
./exemple

    Pour te simplifier la vie, écrit un Makefile, c'est un fichier qui contiens les règles de compilation et automatise la procédure, c'est un peu complexes lorsqu'on débute, mais c'est pratique des que tu veux compiler plusieurs fichiers ensembles, ainsi au lieu de tapper gcc etc…
    Tu te contentes de taper
    make

    En bonus si c'est un projet scolaire c'est classe,

    une fois que tu as compris make, tu utiliseras des outils qui te machent le travail genre cmake

    Pour make tu trouveras par exemple un tuto par là
    http://www.siteduzero.com/informatique/tutoriels/compilez-sous-gnu-linux/la-commande-make-et-le-fichier-makefile-presentation

Suivre le flux des commentaires

Note : les commentaires appartiennent à celles et ceux qui les ont postés. Nous n’en sommes pas responsables.