#include <stdio.h>
#include <stdlib.h>
#include <errno.h>  /* Pour la variable systeme "errno" */
#include <string.h> /* Pour strerror */

int main(int argc, char * argv[]) {
  FILE * f;
  int i;
  if(argc < 2) {
    fprintf(stderr, "usage : %s file1 [file2 [...]]\n", argv[0]);
    exit(1);
  }
  for(i = 1; i < argc; i++) {
    if( (f = fopen(argv[i], "r")) == NULL)
      fprintf(stderr, "Impossible d'ouvrir le fichier %s\nErreur %d : %s\n", 
	      argv[i], errno, strerror(errno));
    else {
      fprintf(stderr, "Fichier %s ouvert et ... ", argv[i]);
      fclose(f);
      fprintf(stderr, "ferme\n");
    }
  }
  return 0;
}

 

 
Ouverture et fermeture de fichiers 
 

 
EXTRAIT DE MAN FOPEN 

#include <stdio.h>
FILE *fopen (const char *path, const char *mode);

DESCRIPTION
La fonction fopen ouvre le fichier dont le nom est contenu dans la chaine pointée par path et lui associe un flux.
L'argument mode pointe vers une chaîne commencant par l'une des séquences suivantes (d'autres caractères peuvent suivre la séquence) :

r 

Ouvre le fichier en lecture. Le pointeur de flux est placé au début du fichier.

r+

Ouvre le fichier en lecture et écriture. Le pointeur de flux est placé au début du fichier.

w 

Ouvre le fichier en écriture. Le fichier est créé s'il n'existait pas. S'il existait déjà, sa longueur est ramenée à 0. Le pointeur de flux est placé au début du fichier.

w+

Ouvre le fichier en lecture et écriture. Le fichier est créé s'il n'existait pas. S'il existait déjà, sa longueur est ramenée à 0. Le pointeur de flux est placé au début du fichier.

a 

Ouvre le fichier en ajout (écriture à la fin du fichier). Le fichier est créé s'il n'existait pas. Le pointeur de flux est placé à la fin du fichier.

a+

Ouvre le fichier en lecture et ajout (écriture en fin de fichier). Le fichier est créé s'il n'existait pas. Le pointeur de flux est placé à la fin du fichier.

 
En cas de réussite fopen renvoie un pointeur sur un fichier, de type FILE. Sinon, elle renvoie NULL et errno contient le code d'erreur.

 

 

#include <stdio.h>
#include <stdlib.h>
#include <errno.h>  /* Pour la variable systeme "errno" */
#include <string.h> /* Pour strerror */

int parcourir(FILE * f) {
  int taille = 0;
  char c;
  while ( fread (&c, 1, 1, f) ) taille++;
  /* CECI EST EQUIVALENT A LA LIGNE PRECEDENTE
    while ( !feof(f) ) { fread (&c, 1, 1, f); taille++;} */
  return taille;
}

int main(int argc, char * argv[]) {
  FILE * f;
  int i;
  if(argc < 2) {
    fprintf(stderr, "usage : %s file1 [file2 [...]]\n", argv[0]);
    exit(1);
  }
  for(i = 1; i < argc; i++) {
    if( (f = fopen(argv[i], "r")) == NULL)
      fprintf(stderr, "Impossible d'ouvrir le fichier %s\nErreur %d : %s\n", 
	      argv[i], errno, strerror(errno));
    else {
      fprintf(stderr, "Fichier %s ouvert, parcouru (%d octets) et ... ", 
	      argv[i], parcourir(f));
      fclose(f);
      fprintf(stderr, "ferme\n");
    }
  }
  return 0;
}

 

 
Ouvrir, parcourir et fermer un fichier 
 

 
 

EXTRAIT DE MAN FREAD 

#include <stdio.h>
size_t fread (void *ptr, size_t size, size_t nmemb, FILE *stream);
size_t fwrite (const void *ptr, size_t size, size_t nmemb, FILE *stream);

DESCRIPTION
La fonction fread lit nmemb éments de données, chacun d'eux représentant size octets de long, depuis le flux pointé par stream, et les stocke à l'emplacement pointé par ptr.
La fonction fwrite écrit nmemb éléments de données, chacun d'eux représentant size octet de long, dans le flux pointé par stream, après les avoir lus depuis l'emplacement pointé par ptr.
VALEUR RENVOYÉE
fread et fwrite renvoient le nombre d'éléments correctement lus ou écrits (et non pas le nombre d'octets). Si une erreur se produit, ou si la fin du fichier est atteinte en lecture, le nombre renvoyé est plus petit que nmemb et peut même être nul.
fread traite la fin du fichier comme une erreur, et l'appelant devra appeler feof(3) ou ferror(3) pour distinguer ce cas.


 

 

#include <stdio.h>
#include <stdlib.h>
#include <errno.h>  /* Pour la variable systeme "errno" */
#include <string.h> /* Pour strerror */

#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>

long parcourir(FILE * f, long taille) {
  long i;
  for(i = 0; i < taille; i++)
    fseek(f, i, SEEK_SET);
  return i;
}

int main(int argc, char * argv[]) {
  FILE * f;
  int i;
  if(argc < 2) {
    fprintf(stderr, "usage : %s file1 [file2 [...]]\n", argv[0]);
    exit(1);
  }
  for(i = 1; i < argc; i++) {
    if( (f = fopen(argv[i], "r")) == NULL)
      fprintf(stderr, "Impossible d'ouvrir le fichier %s\nErreur %d : %s\n", 
	      argv[i], errno, strerror(errno));
    else {
      long taille = 0;
      struct stat buf;
      stat(argv[i], &buf);
      taille = (long) (buf.st_size);
      fprintf(stderr, "Fichier %s ouvert, parcouru (%ld octets) et ... ", 
	      argv[i], parcourir(f, taille));
      fclose(f);
      fprintf(stderr, "ferme\n");
    }
  }
  return 0;
}

 

 
Ouvrir, parcourir et fermer un fichier V2 ... 
 

 


 

 

#include <stdio.h>
#include <stdlib.h>
#include <errno.h>  /* Pour la variable systeme "errno" */
#include <string.h> /* Pour strerror */

/* Pour stat */
#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>

void remplacer(char * s, int l, char c1, char c2) {
  int i;
  for(i = 0; i < l; i++)
    if(s[i] == c1) s[i] = c2;
}

int main(int argc, char * argv[]) {
  FILE * f1, * f2;
  struct stat buf;
  char * txt = NULL;
  if(argc != 3) {
    fprintf(stderr, "usage : %s src_file dst_file\n", argv[0]);
    exit(1);
  }
  if( (f1 = fopen(argv[1], "r")) == NULL) {
    fprintf(stderr, "Impossible d'ouvrir le fichier %s\nErreur %d : %s\n", 
	    argv[1], errno, strerror(errno));
    exit(2);
  }
  if( (f2 = fopen(argv[2], "w")) == NULL) {
    fprintf(stderr, "Impossible d'ouvrir (ou creer) le fichier %s\nErreur %d : %s\n", 
	    argv[2], errno, strerror(errno));
    exit(3);
  }
  stat(argv[1], &buf);
  txt = malloc((int)(buf.st_size) * sizeof txt[0]);
  fread(txt, 1, buf.st_size, f1);
  remplacer(txt, buf.st_size, ' ', '\n');
  fwrite(txt, 1, buf.st_size, f2);
  fclose(f1);
  fclose(f2);
  return 0;
}

 

 
Un mini Rechercher-Remplacer