Fonction de lecture de fichier

Bonjour, je suis nouveaux en c, et je veux utiliser une fonction pour ouvrir mes fichiers (eviter a chaque foix de tester si ouverture ok ... etc)
Voila mon code
///////////////////////////////////////////////////////////////////////////////////////////////////////
/**
 * ouverture d'un fichier
 * @param *directionFichier Le nom du fichier sur le disque
 * @param *file Le nom du fichier en memoire
 * @param *wr savoir si en lecture ou en ecriture
 */
void ouvrir(char directionFichier[256], FILE *file, char wr[256]){
     if((file = fopen(directionFichier, wr)) == NULL ){
      printf("Error while connecting to FILE \'%s\'\n", directionFichier);
      getch();
      exit(EXIT_FAILURE);
    }
}
//////////////////////////////////////////////////////////////////////////////////////////////////////////
il ne me retourne aucune erreur, tout va bien; mais quand je veux lire:
//////////////////////////////////////////////////////////////////////////////////////////////////////////
ouvrir("a991", fichier, "r");
fscanf(fichier, "%s", resultat);
printf("resultat: %s\n", resultat);
//////////////////////////////////////////////////////////////////////////////////////////////////////////
il me lance un erreur de memoire, le fichier ne peut etre lu :(
Quelqu'un pourrait-il m'aider, merci

Merci pour ton aide, et pour le perror c'est pratique comme methode :)

Voila ce que ca donne pour que ca marche :
########################################################################
// fonctions

/**
 * fermeture d'un FILE
 * @param *file Le nom du fichier en memoire
 */
void fermer(FILE **file){
     if(fclose(*file) == EOF){
      perror("erreur de fermeture du fichier");
      printf("Error while trying to close \'%s\'\n", file);
     }
} // fin de fermer

/**
 * ouverture d'un FILE
 * @param *directionFichier Le nom du fichier sur le disque
 * @param *file Le nom du fichier en memoire
 * @param *wr savoir si en lecture ou en ecriture
 */
void ouvrir(const char *directionFichier, FILE **file, const char *wr){
      *file = fopen(directionFichier, wr);
      if(*file == NULL ){
      perror("erreur d'ouverture du fichier");
      printf("Error while connecting to FILE \'%s\'\n", directionFichier);
      getch();
      exit(EXIT_FAILURE);
    }
}

// main
FILE **fichierLoc;
       // en lecture
      ouvrir(fLoc, fichierLoc, "r");
        fscanf(*fichierLoc, "%d", &num); // lecture du num de la pop
      
      if(fclose(*fichierLoc) == EOF){
        printf("Error while trying to close \'%s\'\n", fLoc);
      }

  // pour un fichier en lecture :
  // char **tabPop
fprintf(*fichierEnLecture, "%s", tabPop[num]);
########################################################################

Mon dieux mon dieux DSL les pointeurs c'est pas mon fort lol
j'ais pas trouve comment modifier mon prescedent texte alors je le refait.

########################################################################
// fonctions

/**
 * fermeture d'un FILE
 * @param **file Le nom du fichier en memoire
 */
void fermer(FILE **file){
     if(fclose(*file) == EOF){
      perror("erreur de fermeture du fichier");
      printf("Error while trying to close \'%s\'\n", file);
     }
} // fin de fermer

/**
 * ouverture d'un FILE
 * @param *directionFichier Le nom du fichier sur le disque
 * @param **file Le nom du fichier en memoire
 * @param *wr savoir si en lecture ou en ecriture
 */
void ouvrir(const char *directionFichier, FILE **file, const char *wr){
      *file = fopen(directionFichier, wr);
      if(*file == NULL ){
      perror("erreur d'ouverture du fichier");
      printf("Error while connecting to FILE \'%s\'\n", directionFichier);
      getch();
      exit(EXIT_FAILURE);
    }
}

// main
FILE **fichierLoc;
       // en lecture
      ouvrir(fLoc, fichierLoc, "r");
        fscanf(*fichierLoc, "%d", &num); // lecture du num de la pop
      
      if(fclose(fichierLoc) == EOF){
        printf("Error while trying to close \'%s\'\n", fLoc);
      }

  // pour un fichier en lecture :
  // char **tabPop
fprintf(*fichierEnLecture, "%s", tabPop[num]);
########################################################################

Voila comme ca y a pas de problemes

Bha voila ca continue :(
J'ouvre plusieur fichiers en lecture avec ma fonction ouvrir() -qui marche bien- et je me retrouve avec une erreur de memoire : l'adresse ne peut pas etre ecrite.
J'ais ouvert en lecture puis ferme un fichier, l'ouverture de l'autre fichier n'a pas pose de probleme. Mais si je le laisse ouvert alors il y a un probleme. Quelqu'un peut me dire pourquoi?
#########################################################################
FILE **fishloc;
    ouvrir("fishloc", fishloc, "w");
     // ...
    fermer(fishloc);
FILE **rndSeed;
    ouvrir("RND_seed.97", rndSeed, "r");
    // la pas de probleme
FILE **fichierLocus;
    ouvrir("locus.txt", fichierLocus, "r");
    // la y a un message d'erreur de memoire
########################################################################

j'ais utilise le debugger, il me dis que c'est une erreur de segmentation dans ma fonction ouvrir()
: *file = fopen(directionFichier, wr);
Je sais pas ce que c'est.

Merci enormement. Je nage complettement dans les pointeurs, c'est une catastrophe.

Donc au finale ca donne
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
#include <stdio.h> // FILE, perror
//
// fonctions
//
/**
 * fermeture d'un FILE
 * @param **file Le nom du fichier en memoire
 * @param *directionFichier Le nom du fichier sur le disque
 */
void fermer(FILE **file, const char *directionFichier){
     if(fclose(*file) == EOF){
      perror("erreur de fermeture du fermeture:\n");
      printf("Error while trying to close \'%s\'\n", directionFichier);
     }
} // fin de fermer

/**
 * ouverture d'un FILE
 * @param *directionFichier Le nom du fichier sur le disque
 * @param **file Le nom du fichier en memoire
 * @param *wr savoir si en lecture ou en ecriture
 */
void ouvrir(const char *directionFichier, FILE **file, const char *wr){
      *file = fopen(directionFichier, wr);
      if(*file == NULL ){
      perror("\nerreur d'ouverture du fichier:\n");
      printf("Error while connecting to FILE \'%s\'\n", directionFichier);
      getch();
      exit(EXIT_FAILURE);
    }
}
//
// utilisation
//
FILE *fichLocus;
ouvrir(fLocus, &fichLocus, "r");
fscanf(fichLocus, "%d %d", &n, &m);
fermer(&fichLocus, fLocus);
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
Voila j'espere que ma souffrance evitera a d'autres noob la meme peine

tu ne devrais pas t'inquietter, les pointeurs en langage C n'ont rien de complexe, c'est juste qu'il faut savoir quelques bases la dessus.

Un pointeur est une variable qui contient l'adresse (souvent virtuelle, mais ne t'en occupe pas) d'une autre variable.

il faut connaître 2 opérateurs unaires ( op<operande>):

• l'opérateur * , qui permet de déférencer un pointeur, c'est à dire de retourner la valeur de la variable pointée par le pointeur.
• l'opérateur & (address of) qui retourne l'adresse de la variable sur laquelle il s'applique.

En application:

int n = 5; /* un entier */
int *p = &n; /* un pointeur sur entier p initialisé avec l'adresse de n (grace à l'opérateur &) */

p == <adresse de n>
*p == <valeur de n, c'est à dire 5>

au niveau des types:

n est de type int
&n est de type int* (pointeur constant)
p est de type int*
*p est de type int (puisque c'est la valeur de la variable de type int pointée par p)
&p est de type int** (pointeur constant)

un cas d'utilisation: faire en sorte qu'une fonction puisse modifier un de ses paramètres

int f(int a); /* f ne peux pas modifier "a" car en C les paramètres sont toujours passés aux fonctions pas copie */

la solution, plutot que de passer la valeur de a, c'est de passer sont adresse (qui est de type int*).

int f(int *p)
{
    *p = 5; /* l'opérateur * permet d'acceder à la valeur */
   return 0;
}

et l'appel donne

f(&a); /* on lui passe l'adresse de a */

c'est pour ca que:

FILE* fishloc;
ouvrir("fishloc", &fishloc, "w");