Bonjour,    
 
cette situation traine dans ma tête depuis trop longtemps, sans succès je n'ai pu la résoudre.
Je souhaite ouvrir un fichier et dédier une fonction à l'ouverture de ce fichier.
On balance l'emplacement du fichier dans la fonction et celle ci s'occupe d'ouvrir le fichier.
On reste simple, on considère qu'il existe et qu'il contient des données, l'emplacement est valable aussi.
Donc :  

 
Cette fonction sera donc appelée à chaque fois que je souhaite ouvrir un fichier.
(Je souhaite déclarer un pointeur localement puis agrandir sa portée)
A l'exécution, des erreurs de violation d'accès sont signalés.
 
Il y a effectivement un problème de portée du pointeur fichier.
Les mots clés extern ou static peuvent-ils venir à mon aide???

l'exemple que tu donnes a l'air correct, donne un exemple complet de code qui te pose problème.

man fopen
 
les arguments ne sont pas bons.

Contexte : je souhaite ouvrir un fichier, le copier dans un buffer et afficher ce buffer sur la console.
Pour cela voici le main ()

Fonctions:

• void retire_chariot (char*); ==> retire '\n' à la fin de la chaine saisie par l'utilisateur
• int affiche_fichier (char *); ==> ouvre le fichier, le copie dans un buffer et l'affiche sur la console.
• FILE* ouvre_fichier(char * adresse); ==> ouvre le fichier et renvoie le pointeur fichier associé au fichier ouvert.

Ci joint les sources.

Le problème n'existerai pas si j'utiliserais fopen() directement dans affiche_fichier(...), je souhaite comprendre pourquoi le prog plante...

Edit: effectivement pour fopen, c'est corrigé mais cette erreur n'est pas à l'origine du plantage.

comme l'a fait judicieusement remarquer Taz, tu as une erreur au niveau des arguments que tu envoies à fopen dans ta fonction ouvre_fichier.

Edit: Ouah, j'ai cliqué sur éditer au lieu de répondre (et sur le mauvais message en plus).
 
Bah, chais pas ce que tu fais. Mais le programme suivant, récupérer de ton lien et corriger de deux ou trois erreurs, marche_chez_moi™ (WinXP, mais il n'y aucune raison que ça marche par ailleurs):
 
Bref, défini ce que tu appelles "plantage". Vois-tu un SIGSEGV ou SIGTRAP en lançant le programme dans un debugger ? Arrêt brutal au milieu du code ? Si tu as valgrind, y a t-il des warnings particuliers ?
 

J'ai rajouté exit au dernier moment, ce n'est pas la cause du plantage, commentez le pour voir.
Pour fopen, oui il y a une erreur dans le 2eme argument mais ce n'est pas la cause du plantage. (Cf. post précédent.)
De toute façon, le fichier à ouvrir existe et le programme fonctionne parfaitement en utilisant fopen() au sein de affiche_fichier().
C'est le passage de fopen (et de la déclaration de FILE * fichier dans une fonction a part (ouvrir_fichier()) qui pose problème.
 
Je ré-explique le problème :  

• chaque variable "vit" dans le bloc où elle a été déclarée, ceci est aussi valable pour un pointeur.
• même si j'arrive à appeler ce pointeur hors de son bloc, l'appel amènera à une exception.

En considérant ces deux énoncés est-il possible d'appeler un pointeur en dehors de son bloc sans utiliser de variables globales.
Dans ce cas là pouvez-vous m'expliquer le fonctionnement de fonctions qui créent et renvoient un pointeur (fopen, fgets, ...).

Oui... mais le pointeur pointe (d'où son nom) vers une zone mémoire accessible de partout (sauf si t'as commis l'erreur de le faire pointer vers une autre variable locale)
 

Le pointeur non. La variable qui stockait l'adresse a disparu. Mais si cette adresse est stockée dans une seconde variable (ou renvoyée par la fonction), tu peux toujours aller toper ce qui est pointé car ça, ça n'a pas disparu !!!
 
Un exemple tout simple

void modif(int*);
 
int main()
{
    int i=10;           // Je déclare un int
    printf("i=%d\n", i);    // Je l'affiche pour voir
 
    modif(&i);               // Je passe l'adresse de ce int à une fonction
    printf("i=%d\n", i);    // Je l'affiche pour voir
    return 0;
}
 
void modif(int* pt)
{
    // La fonction a reçu l'adresse d'un int. Elle stocke cette adresse dans une variable de type "int étoile"
    // Pourquoi "int étoile" ? Parce que "ce qu'il y a au bout de pt" (donc *pt) est de type "int".
    // Et donc si "*pt" est de type "int", alors "pt" est de type "int... étoile" (comme pour une équation, si le mot "étoile" disparait de la phrase d'un coté alors je la remets de l'autre coté)
    // On est d'accord: pt est local
 
    (*pt)=500;        // Je rentre 500 dans la case pointée par pt.
 
 
}  // Fin de la fonction: pt a disparu... mais pas ce qu'il y avait à "étoile pt" !!!

 
L'exemple inverse... mais qui foire

int *modif();
 
int main()
{
    int *pt;           // Je déclare un pointeur destiné à recevoir un int
 
    pt=modif();               // Je récupère dans pt ce que me renvoie ma fonction
    printf("*pt=%d\n", *pt);    // Je l'affiche pour voir
    return 0;
}
 
int* modif()
{
     int i;                // Je déclare i (local)
 
     i=500;             // Pas de pb
 
    return(&i);        // Je renvoie l'adresse de ma variable... alors que celle-ci va disparaitre !!!
}
// Fin de la fonction: i a disparu, sera réutilisé par le compilo pour autre chose mais j'ai récupéré son adresse
// Cette adresse ne correspond à plus rien de valide !!!

 
Le 3° comme le 2° mais qui fonctionne

int *modif();
 
int main()
{
    int *pt;           // Je déclare un pointeur destiné à recevoir un int
 
    pt=modif();               // Je récupère dans pt ce que me renvoie ma fonctionfonction
    printf("*pt=%d\n", *pt);    // Je l'affiche pour voir
    return 0;
}
 
int* modif()
{
     int *pt;            // Je déclare un pointeur (local)
 
     pt=malloc(sizeof(int));    // J'y alloue de la mémoire pour stocker un int
     // Cette allocation est prise dans la mémoire globale du programme et pas dans la mémoire locale de la fonction
 
     (*pt)=500;             // Pas de pb
 
    return(pt);        // Je renvoie l'adresse de la zone allouée - Cette zone ne disparaitra pas (même si pt disparait) !!!
}

1) quand tu fais fp=fopen("...", "r/w/a" )
a) la fonction commence par allouer une zone mémoire suffisante pour y stocker les outils de manipulation du fichier
b) la fonction y stocke lesdits outils. On pourra y trouver par exemple l'endroit du fichier où tu te trouves, la taille du fichier, le mode d'accès (r/w), bref divers outils quoi
c) la fonction te renvoie l'adresse de cette zone mémoire (qui se trouve dans la mémoire du programme donc accessible de partout)
 
2) quand tu fais du fgets(..., ..., fp) => la fonction fgets() récupère cette zone mémoire donc peut aller utiliser les outils qui y sont pour lire le fichier et te renvoyer les data
 
3) quand tu fais fclose(fp) => la fonction fclose libère la zone mémoire

Merci de m'avoir éclaircit sur ces points.
Effectivement la déclaration d'un pointeur restait locale au bloc en cours mais la zone allouée reste disponible globalement, pour peu qu'on ai son adresse.
 
 
Problème résolu.