Un peu d'aide sur un mélange de cat/tail

[Faust]

Il n'y a pas quelqu'un qui voudrait m'aider? je suis entrain de virer complètement fou. J'ai 18 début de programme qui marche pas

Ca fait 1 semaine que je cherche la solution et j'y arrive pas. Pourtant c'est pas que j'ai pas essayé!

Sur Linux,

Voilà, j'essai de faire comme un "cat" sous Unix mélangé avec un "tail". Autrement dit, ca affiche le nombres de lignes demandées passées en paramètres, dans tous les fichiers passé en paramètres. Si aucun paramètre n'est passé, il affiche que les 10 dernières lignes.

La seule chose que j'ai réussi à faire, c'est d'afficher les lignes entres le début et la fin.

  #include <stdio.h>  
 #include <errno.h>  
  int main(int argc,char *argv[])  
  {  
    FILE *f;  
    int d,f,c=0;  
    char l[100000];  
     
    if (argc!=4)  
    {  
      printf("Usage: %s <debut> <fin> <fichier>\n",argv[0]);  
      return 1;  
    }  
     
    if ((f=fopen(argv[3],"r"))==NULL) 
    { 
      perror("fopen()"); 
    return 1;}  
     
    sscanf(argv[1],"%d",&d);  
    sscanf(argv[2],"%d",&f);  
     
    while (fgets(l,100000,f))  
    {  
      c++;  
      if ((d<=c)&&(c<=f)) fputs(l,stdout);  
        if (c>f) break;  
      }  
     
    fclose(f);  
    return 0;  
  }  

[Faust]

Bon, je réussis à lire le fichier....reste à trouver comment passer le paramètres d'afficher n lignes

#include <stdio.h>
main (int argc, char *argv[])
{
int i, c;
for (i=1; i<argc; i++)
{
FILE *f;
f = fopen (argv[i], "r");
while ((c = fgetc (f))!=EOF)
fputc (c, stdout);
fclose (f);
}
fflush (stdout);
exit (0);
}

[Faust]

Bon, voilà qu'il me sort une erreur de segmentation

#include <stdio.h>
main (int argc, char *argv[])
{
int i;
int c  = 10;
for (i=1; i<argc; i++)
{
FILE *f;
f = fopen (argv[i], "r");
while ((c = fgetc (f))!=EOF)
 if (argc)
   {
       int   a;
        a = atoi(*argv);

     if (a < 0)
       {
         c = -a;

         argc--;
         argv++;
       }
else ((c == '\n') && !(--c)
   }
fputc (c, stdout);
fclose (f);
}
fflush (stdout);
exit (0);
}

[mogwai93]

je t'explique le fonctionnement du passage en paramètre.

Disons que ton fichier C crée un fichier TEST.EXE

si tu executes (commandes DOS)

TEST fichier1 fichier2 fichier3 10

alors

(argc = nb de parametre, executable compris)

argc = 5

argv[0] = "TEST"

argv[1] = "fichier1"

argv[2] = "fichier2"

argv[3] = "fichier3"

argv[4] = "10"

donc pour ton pb :

#include <stdio.h>
main (int argc, char *argv[])
{
   if (argc < 2)
  {
        /*    pas de parametre   */
        exit (1);
  }
  else
  {
       /* Traitement à effectuer    */
   }
}

pour le else

tu transformes le dernier chiffre en entier avec la méthode atoi :

le dernier chiffre : argv[argc - 1]

si "atoi' te renvoies une erreur, alors N = 10

ensuite tu lis tes fichiers (faut supposer que ce sont des fichiers texte)

car avec les fichiers binaires....ca peut planter

par contre, il faut lire les N dernières lignes ?

pour les N premières, c'est pas compliqué

mais pour les N dernières, t'es obligé de lire N par N lignes

(tu stockes les N lignes dans un tableau)

jusqu'à fin du fichier

et dès que tu es à la fin du fichier, tu affiches le tableau....

en espérant avoir pu t'aider

[mogwai93]

Bon, voilà qu'il me sort une erreur de segmentation

#include <stdio.h>
main (int argc, char *argv[])
{
int i;
int c  = 10;
for (i=1; i<argc; i++)
{
FILE *f;
f = fopen (argv[i], "r");
while ((c = fgetc (f))!=EOF)
 if (argc)
   {
       int   a;
        a = atoi(*argv);

     if (a < 0)
       {
         c = -a;

         argc--;
         argv++;
       }
else ((c == '\n') && !(--c)
   }
fputc (c, stdout);
fclose (f);
}
fflush (stdout);
exit (0);
}

pour ton pb de segmentation

ca doit venir de ta boucle while

au niveau de :

a = atoi(*argv);

==> remplace par

a = atoi(argv[i]);

et de

argv++;

==> ta boucle for, fait la même chose....

ensuite

je ne vois pas l'intéret de reduire le nb de param

argc--;

de tte façon, faut que tu revois ta boucle while

voila le prototype général de ton programme

1) détection du nb de paramètre

2) est-ce que le dernier param est un nombre

oui --> N = atoi (argv[argc - 1])

Nb_fichier = argc - 2

non --> N = 10

Nb_fichier = argc - 1

3) lecture des fichiers et traitement

pour i de 1 à Nb_fichier

ouvrir en lecture argv

Traitement

fermer argv

4) Fermeture du programme

[Faust]

Ca commence tu à avoir plus de sens? Je suis vraiment pas doué en C (certains le savent ici)

main (int argc, char *argv[])
{
int i;
int n  = 10;

if argv[0]=n>0        	/* Si le premier argument est un nombres plus grand que 0
{
for (i=1; i<argc; i++)
{
FILE *f
n = atoi(argv[i]);    /* Envoi le nombre de ligne dans n
f = fopen (argv[agrc+1], "r"); /* Tous les fichiers passé en paramètres    
while ((n = fgetc (f))!=EOF)	/* Tant que tu n'est pas a la fin du fichier
fputc (n, stdout);                   /* Sort le n lignes

}


if (argc[0] == 1)  /* Si aucun nombre de lignes passé
{
fputc (n, stdout);  /* Affiche 10 lignes par défaut
}
fclose (f);

[mogwai93]

alors voila une ebauche pour ton programme :

#include <stdio.h>
#define N 10

main (int argc, char *argv[])
{
  if (argc < 2)
 {
       /*    pas de parametre   */
       printf("Usage: %s .....\n",argv[0]);  /* tu remplaces les ... par tes param */
       exit (1);
 }
 else
 {
      /* Traitement à effectuer    */
      int i;
      int Nb_lignes;


      FILE *f;

      /* faut vérifier le nb de parametres */
      
      Nb_lignes = atoi (argv[argc - 1]);

      if Nb_lignes < 0    /* le dernier param n'est pas un nombre */
           Nb_lignes = N;



      for (i = 1; i < argc -1; i++)
      {
          f = fopen (argv[i], "r");
          /* faut vérifier que le fichier existe */

          /* les traitements à faire */

          fclose (f);
      }
  }
}

pour t'entrainer, essayer dejà de faire la commande type ou more :

tu passes le nom de ton fichier en parametre

et tu l'affiches

et si pas de fichier passé en parametre,

tu affiches un fichier par defaut (genre fichier d'aide)

et fait d'abord l'algo sur papier

ensuite ce sera plus facile de le coder en C

[Sentinel]

Dans ce cas précis, une liste circulaire paraît adaptée. Pour l'implémentation, tu ne peux pas utiliser les tableaux, étant donné que tu ne connais pas le nombre d'éléments de la liste : utilise donc une liste chaînée.

Il faut la remplir circulairement, au fur et à mesure que tu lis le fichier. A la fin, il suffira d'en afficher le contenu et le tour est joué.

[Faust]

Pour ceux que ca intéressent, j'ai réussi à faire quelque chose...c'est laid et mal coder mais ca donne exactement le résultat voulu

reste qu'a mettre une gestion d'erreur que j'arrive pas, mais bon ca c'est un détail.

genre ./tail -4 fichier1 fichier 2 -->ok

./tail fichier --> ok 10 lignes par défaut

./tail 4 fichier1 fichier2 --> Erreur, usage ./tail -n <fichier>

#include <stdio.h>
#include <ctype.h>

int main(int argc, char* argv[])
{
int k;
int j = -10;
int t = -10;

char* nomsFichiers;
FILE* streamin;

for (k = 1; k < argc; k++)
{
 if (argv[k][0] == '-')
 {
 	t = atoi(argv[k]+1);
 	if (t == 0)
 	{
   printf("Parametres incorrects"\n");
 	}

 	t = -t;
 	j = t;

 }
 else
 {
 	printf("\nDernieres %d lignes \n", -t);
 	nomsFichiers = argv[k];

 	if ((streamin = fopen(nomsFichiers, "r")) == NULL)
 	{
   printf("Impossible d'ouvrir le fichier: %s. \n", nomsFichiers);
   return 2;
 	}

 	printf("du fichier %s \n\n", nomsFichiers);

 	int compteLignes = 1;
 	int totalLignes = 0;
 	int debutLigne = 0;
 	int ch;

 	while ((ch = getc(streamin)) !=EOF)
 	{
   if ((ch == '\n')
   {
   	totalLignes++;
   }
 	}

 	if (j > 0)
 	{
   debutLigne = 1+j;
 	}
 	else
 	{
   debutLigne = totalLignes +j+2;
 	}

 	if ((streamin = fopen(nomsFichiers, "r")) == NULL)
 	{
   printf("Impossible d'ouvrir le fichier: %s.\n", nomsFichiers);
   return 2;
 	}

 	while ((ch = getc(streamin)) !=EOF)
 	{
   if (compteLignes >= debutLigne-1)
   {
   	printf("%c", ch);
   }

   if (ch == '\n')
   {
   	compteLignes++;
   }
 	}
 }
}
fclose (streamin);
return 0;
}