Initialisation d'un pointeur de type 'FILE *'

Version imprimable

Bonjour,
Je ne comprend pas pourquoi mais à force de diagnostique et de rechcerches depuis plus d'une heure je viens de m'apercevoir qu'un pointeur de type 'FILE *' (peut-être n'est-ce pas le seul type) est initialisé à 0 ('NULL') en présence de déclaration de tableaux de pointeurs (même si cette déclaration est faite quelques lignes en dessous) et initialisé à une valeur (aléatoire à première vue) lorsque qu'aucun tableau de pointeur n'est défini.

Je ne comprends plus rien d'autant plus que quand je défini ce pointeur grâce à fopen il n'est toujours pas initialisé si des tableaux de pointeurs ont été définis...

Est-ce que quelqu'un a une explication (simple de préféence, je débute :p) à mon problème?

Merci! :)

EDIT : à titre d'exemple, après avoir basardé tout mon pour trouver le problème voici le bout de code qui m'a permit de faire mon diagnostique :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 #include <stdio.h> int main(void) { FILE * rien; if(rien == NULL) printf("Problème\n"); char *pers[6] = {"je", "tu", "il", "nous", "vous", "ils"}; char *term[6] = {"e", "es", "e", "ons", "ez", "ent"}; return 0; }

16/01/2008, 22h35
hegros

Est-ce que tu as un exemple de code a proposer pour exposer ton incompréhension.

Citation:
Envoyé par sdumasp
Code:

1 2 3 4 5 6 7 8 9 10 11 12 #include <stdio.h> int main(void) { FILE * rien; if(rien == NULL) printf("Problème\n"); char *pers[6] = {"je", "tu", "il", "nous", "vous", "ils"}; char *term[6] = {"e", "es", "e", "ons", "ez", "ent"}; return 0; }
Qu'est-ce que tu constates au juste ? rien est une variable locale automatique qui va être empilé sur la pile donc dedans tu peux avoir tout et n'importe quoi si tu ne l'initialises pas. Cela peut être null comme autre chose il n'y a, désolé, a priori aucun mystére.

17/01/2008, 07h33
sdumasp

sisi tant qu'au moins un des deux tableaux de pointeurs est toujours déclaré, 'FILE * rien' est initialisé à 'NULL'

Essaie ensuite en commentant les deux déclarations de tableaux et 'FILE * rien' sera initialisé avec une valeur variable. (en tout cas sous Code::Blocks)
17/01/2008, 09h09
Melem

Lorsqu'on initialise un tableau ou une structure tous les éléments restants non initialisés sont remplis par des 0. Par exemple si tu fais :

Code:

int t[10] = {0, 10, 20, 30, 40};

t[5], t[6], t[7], t[8] et t[9] seront initialisés à 0.

Sur x86 les variables locales sont placées sur la pile (donc dernier arrivé, premier sorti). Par exemple si on a :

Code:

int a, b, c, d, e, * p = &e;

Alors :
p[0] = e
p[1] = d
p[2] = c
p[3] = b
p[4] = a

Et comme dit plus haut, si tu initialises un tableau, tous les éléments restants non initialisés seront initialisés à 0 ... Tout peut arriver (selon le compilateur, le système, etc.). Moi en tout cas (Code::Blocks, Windows XP) j'ai pas ce "phénomène".
17/01/2008, 13h25
sdumasp

mais je ne comprend pas bien le rapport entre mes tableaux de pointeur et mon 'FILE * rien'...
quand j'ai mes tableaux, 'FILE * rien' est TOUJOURS initialisé à 'NULL' tandis que sans les tableaux, il est TOUJOURS initialisé aléatoirement mais jamais 'NULL'...

en plus quand j'ai mes tableaux, même si je déclare 'FILE * rien' et que je l'initialise après 'rien = fopen(nomfichier, "w")' par exemple, il est dans tous les cas nul...
17/01/2008, 13h32
hegros

Tes tableaux et ton FILE* sont sur la pile ! Par définition une variable locale automatique non initialisée a comme valeur n'importe quoi car on ne peut faire savoir ce qu'il y avait sur la pile avant. Il n'y a pas un petit bonhomme vert caché dans ton micro qui te fait une blague foireuse pour te faire péter les plombs.

Pour le fopen qui te renvoi NULL c'est que le fichier n'existe pas ou qu'il est impossible de l'ouvrir.
17/01/2008, 13h34
sdumasp

donc en fait je déclare 'rien', il se met tout en bas de la pile et dès que d'autres trucs arrivent dans la pile, il est mis à 0?
17/01/2008, 13h39
PsychoH13

Non, rien n'est dit à ce propos sur la pile, il s'agit d'un comportement indéfini il est donc formellement à éviter !

faire un "= NULL" pour initialiser ta variable ne coûte rien et ça évite de faire des paris idiots que celui que tu veux faire, donc fais-le et tout ira bien.

je ne veux justement pas l'initialiser à 0 et il n'y a aucun pari idiot.

j'avais juste un problème avec ma fonction fclean qui ne s'exécutait pas justement parce que mon 'FILE' était nul
je peux donc changer ma fonction fclean :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
int fclean (char *s_buffer, FILE * stream)
   {
   int err = 0;
   if (s_buffer != NULL && stream != NULL)
   {
      char *pc = strchr (s_buffer, '\n');
 
      if (pc != NULL)           /* La saisie n'a pas ete tronquee */
      {
         /* On remplace '\n' par le caractere nul '\0' */
         *pc = 0;
      }
   else
   {/* La saisie a ete tronquee, on purge le flux d'entree */
       int c;
       while ((c = fgetc (stream)) != '\n' && c != EOF)
       {
       }
       err = 1;
   }
   return err;
   }

par la suivante?

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
int fclean (char *s_buffer, FILE * stream)
   {
   int err = 0;
   if (s_buffer != NULL)
   {
      char *pc = strchr (s_buffer, '\n');
 
      if (pc != NULL)           /* La saisie n'a pas ete tronquee */
      {
         /* On remplace '\n' par le caractere nul '\0' */
         *pc = 0;
      }
   }
   if(stream != NULL)
   {/* La saisie a ete tronquee, on purge le flux d'entree */
       int c;
       while ((c = fgetc (stream)) != '\n' && c != EOF)
       {
       }
       err = 1;
   }
   return err;
   }

ce qui me permet plutôt que de déclarer un FILE non nul qui ne sert à rien de lancer fclean avec comme deuxième argument un petit 'NULL'?!

17/01/2008, 13h55
PsychoH13

Bah justement non, tu veux faire exactement ce qu'il ne faut pas faire !
Tu dois TOUJOURS tester qu'un objet est initialiser ou pas avant d'exécuter une fonction dessus !
Imagine que tu utilises un fread() sur un fichier dont tu n'as pas initialiser le pointeur, ou qui n'a jamais reçu la valeur de retour de fopen().
Ta variable contiendra n'importe quelle adresse, et qu'est-ce que ça fera si fread() tente de lire l'adresse toute pourrie que tu lui as donné ? Bah tu auras un segmentation fault !

C'est pour ça que l'initialisation est importante ! C'est pour détecter si une variable (et surtout un pointeur) est valide !
17/01/2008, 14h18
Médinoc
La bonne pratique, c'est de TOUJOURS initialiser un pointeur.
- Soit avec une addresse valide (retour de malloc(), de fopen() etc.)
- Soit avec NULL.
17/01/2008, 18h51
sdumasp

oui oui j'avais bien compris tout ça mais ici le pointeur 'FILE * rien' n'était déclaré que dans l'utilité de la fonction 'fclean()' puisque celle-ci ne nettoie une saisie avec 'fgets()' que si elle a un pointeur non nul en argument en plus de la chaîne de caractères.
je conviens que c'est pas terrible, voire limite, de faire ce genre de manip mais c'est ce qu'il me faut si je veux éviter l'usage de 'scanf()'

donc mon changement de la fonction 'fclean()' conviendrait?
si je n'ai donc pas de pointeur 'FILE *' utile dans mon programme je pourrais donc utiliser 'fclean()' de la façon suivante :

Code:

fclean(chaîne, NULL);
17/01/2008, 18h55
PsychoH13
Je comprends pas ce que tu veux faire...

Si tu veux nettoyer le flux d'entrer en utilisant ta fonction, pourquoi ne passerais-tu pas à ta fonction les fichiers standards ?
1. stdin : flux d'entrée
2. stdout : flux de sortie
3. stderr : flux pour les erreurs
17/01/2008, 18h58
sdumasp

non en fait cette fonction me sert
soit à nettoyer un flux
soit à nettoyer le caractère de saut de ligne à la fin d'une saisie via 'fgets()' et dans ce cas il me faut un flux en plus si j'utilise la version originale de 'fgets()' et un flux non nul d'où mon utilisation limite de 'FILE *'
17/01/2008, 19h05
PsychoH13

Pas la peine de faire l'économie de fonction tu sais !
Fais deux fonctions séparées, une qui nettoie un flux et l'autre qui remplace le caractère finale d'une chaîne de caractères.
17/01/2008, 19h09
sdumasp

ben j'utilise la foncton que m'avais donné Emmanuel Delahaye donc j'me suis pas posé de question quant à son efficacité :)

donc je peux faire deux fonctions, une pour nettoyer le flux et une pour nettoyer la saisie? en gros deux fonctions qui correspondent aux deux parties de la fonction 'fclean()' actuelle?
sinon juste à titre indicatif pour mon expérience personnelle, les changement que j'ai fais quelques posts plus haut sur l'originale 'fclean()' sont-ils valables?! ou corrects en tout cas?!
17/01/2008, 20h13
PsychoH13

Oui, ton changement est bon, et il justifie d'autant plus la séparation en deux fonctions, puisque la première partie s'occupe de la chaîne de caractère et la deuxième s'occupe du buffer, donc faire une seule fonction pour ces deux processi différent n'a aucun sens.
17/01/2008, 20h28
sdumasp

ok je fais ça merci! :)
17/01/2008, 21h27
Médinoc

Si, ça a un sens: On ne fait la purge du FILE* que si le \n n'a pas été trouvé dans la chaîne...
17/01/2008, 21h34
PsychoH13

Le else n'avait pas de sens dans la première version de la fonction. S'il veut juste purger un fichier, pourquoi utilise-t-il une fonction qui fait la purge d'une chaîne de caractères?
17/01/2008, 21h37
Médinoc

Parce que la fonction fclean() du forum n'est pas "purge d'un fichier", mais "purge d'une lecture sur un fichier"...

Mais on peut toujours faire un truc de ce genre:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
//Returns 0 if OK, a negative value if EOF.
int fpurge(FILE *f)
{
	int c;
	while((c=fgetc(f))!=EOF && c!='\n')
	{ }
	return (c==EOF ? -1 : 0);
}
 
/* Returns a nonzero value if found, zero if not. */
int truncate_newline(char *str)
{
	int bRet=0;
	if(str!=NULL)
	{
		char *pNewline = strchr(str, '\n');
		if(pNewLine!=NULL)
		{
			bRet = 1;
			*pNewLine = '\0';
		}
	}
	return bRet;
}
 
/* Returns 0 if buffer is full, a positive value if line is complete,
   a negative value if EOF (implies buffer full). */
int fclean(char *str, FILE *f)
{
	int ret = 1;
	if(!truncate_newline(str))
		ret = fpurge(f);
	return ret;
}

18/01/2008, 14h23
Melem

Citation:

Envoyé par sdumasp

mais je ne comprend pas bien le rapport entre mes tableaux de pointeur et mon 'FILE * rien'...
quand j'ai mes tableaux, 'FILE * rien' est TOUJOURS initialisé à 'NULL' tandis que sans les tableaux, il est TOUJOURS initialisé aléatoirement mais jamais 'NULL'...

Dans ton exemple term[12] = pers[6] = rien. En initialisant pers et avec un compilo mal reglé (ou autre facteur (surnaturel par exemple :mouarf:)) rien sera également initialisé à 0.