Discussion :

[petitclem]

Bonjour à tous,

j'ai ouvert un fichier avec la fonction fopen(), et j'aimerai savoir s'il existe une fonction qui test si le fichier est vide car j'inscris ensuite des données à l'intérieur.
Par exemple buf[0],buf[1], ... et j'aimerai qu'il soit inscrit une seule fois le buf[0] en début de fichier et que par la suite il y ai buf[1]buf[2], puis buf[1]buf[2].

Donc je pensai qu'il doit y avoir une fonction qui teste le contenu d'un fichier : Si le contenu du fichier est vide, inscrire buf[0], Sinon passer à la suite.

Voila, j'espère que je me suis bien exprimé !!!

Merci d'avance, et à bientôt !

[koala01]

Salut,

Tu peux déjà te baser sur l'entrée de la FAQ qui traite du calcul de la taille d'un fichier: si cette taille vaut 0, c'est que le fichier est vide

[petitclem]

Ok merci, je vais jeter un coup d'œil !

[petitclem]

Je ne pense pas que c'est cela qu'il me faut, autrement je pourrai faire : Si position du curseur début = position curseur fin alors inscrire buf[0], Sinon inscrire la suite !!!

Non ???

Et si c'est possible, avec quelle fonction ???

[Lucien63]

Si un fichier vide n'est pas un fichier de taille zero, alors je ne vois pas ce que c'est ????!!!??

Dit nous ce que tu appelles un fichier vide ?

Un fichier c'est quelque chose de concret, c'est comme une boîte de petit pois,
si il n'y a pas de petits pois elle est vide, s'il il en a un, elle n'est pas pleine mais elle n'est pas vide.

[petitclem]

Mais si pourtant !!!

J'ai fait :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
 
	if (sizeof(fichier)==NULL)
				{
					fprintf (fichier, "\n");
					fprintf (fichier, "%d", buf[4]);
					fprintf (fichier, "%d", buf[5]);
					fprintf (fichier, "%d\n", buf[6]);
				}
 
 
 
					FormatFloat("0.000",buf[9]) ;
					fprintf (fichier, "%d", buf[9]/10);
					fprintf (fichier, " ");
					fprintf (fichier, "%d", buf[11]/10);
					fprintf (fichier, " ");
					FormatFloat("0.0",buf[13]) ;
					fprintf (fichier, "%d", buf[13]/10);
					fprintf (fichier, " ");
					fprintf (fichier, "%d", buf[14]);

Mais ça ne marche pas

[Lucien63]

Mais si pourtant !!!

Mais si Quoi ?

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

if (sizeof(fichier)==NULL)

Tu peux me dire ce que tu test là ???!!?? ??!!

Surement pas la taille d'un fichier !!!

Es-tu seulement aller voir le lien de la faq que t'as donné koala01 ??!??

[ram-0000]

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
 
if (sizeof(fichier)==NULL)
{
...
}

Ce n'est pas la bonne manière pour savoir si un fichier est vide, tu n'as pas bien regardé dans la FAQ

Vu que tu utilises les fonctions fprintf(), pour rester cohérent, utilise la fonction stat() pour obtenir la taille du fichier.

[Davidbrcz]

Sinon, Comme la dit Lucien63, donne nous ta définition de ce qu'est un fichier vide, car un fichier rempli de blanc peut être un fichier vide comme pas. Ca dépent du point du vue.

[petitclem]

OK, et bien un fichier de type texte avec pas encore de données inscrites à l'intérieur !



Cela peut il marcher avec la fonction stat () ??

[ram-0000]

OK, et bien un fichier de type texte avec pas encore de données inscrites à l'intérieur !

Donc pour toi, un fichier vide a une taille de 0 octets

Si oui, tu peux savoir si ce fichier est vide (taille 0) avec la fonction stat()

[Davidbrcz]

Le code suivant fait ce que tu demande

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
 
#include <stdlib.h>
#include <stdio.h>
 
int main(int argc, char const *argv[])
{
    FILE* fichier = NULL;
    fichier = fopen("test.txt", "r");
 
    if (fichier != NULL)
    {
        int i=0;
 
        // Boucle de lecture des caractères un à un
        if(fgetc(fichier) != EOF)
        {
            i++;
           rewind(fichier);
        }
	if(i==0)
	    printf("Vide \n");
	else
	    printf("Pas Vide \n");
 
        fclose(fichier);
    }
    return 0;
}

Edit: après test, utilise la commande de ram_0000
Edit2; fonction seulement présente sur les système unix non ?

[petitclem]

Oui c'est cela exactement : si le fichier a la taille de 0 octets, j'inscris buf[0], sinon je passe à la suite.

J'étais en train d'essayer d'utiliser la fonction stat() (pas très facile j'ai l'impression, mais si c'est juste une impression ), c'est donc bien cette fonction que je peux utiliser dans mon cas ???

[koala01]

déjà, tu utilise visiblement un pointeur FILE* à la mode C pour ouvrir ton fichier...

Je te conseillerais donc d'utiliser de préférence les classes de flux de fichier fournies par le C++ (ifstream et ofstream), disponibles dans l'espace de noms std par inclusion du fichier d'en-tête <fstream>

Tu te rendra rapidement compte du fait que la gestion des fichiers devient vraiment plus simple

En outre, il faut savoir que FILE* est un type dont la taille sera connue ad vitam: une taille suffisemment grande pour représenter l'ensemble des adresses mémoires accessibles.

La raison est simple: FILE* est un pointeur, et il respecte donc la définition d'un pointeur: une variable particulière en cela qu'elle contient... l'adresse à laquelle on trouve l'élément réel

Ceci dit, la grosse difficulté vient qu'effectivement, il n'est pas possible d'ouvrir un fichier en lecture (pour pouvoir déterminer sa taille) et en écriture (pour pouvoir y insérer des informations) en même temps.

Ce que tu peux donc faire, c'est utiliser la propriété qui veut qu'une variable est détruite lorsque l'on sort de sa portée (pour un flux de fichier, cela signifie qu'il sera correctement fermé), et calculer la taille du fichier.

Cela pourrait donner un code proche de

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
35
int main()
{
    bool empty=true;
    {
        /* ouvrons et rendons nous directement à la fin du fichier */
        std::ifstream ifs("fichier.txt", ios::ate);
        /*récupérons la position du curseur */
        size_t pos=ifs.tellg();
        /* et vérifions si elle vaut 0
         * si c'est le cas, le fichier est vide (sinon, il... ne l'est pas)
         */
        empty=(pos==0);
    }
    /* dans ton cas, tu as sans doute un buffer proche de
     */
    float buffer[10];
    /* ouvrons maintenant le fichier en écriture, en plaçant le curseur de
     * manière à ragjouter des informations*/
 
    /* si tu as une boucle à gérer, ce sera sans doute à partir d'ici ;) */
    std::ofstream ofs("fichier.txt", std::ios::app);
    /* si le fichier est vide, écrivons la valeur de buffer[0] */
    if(empty)
    {
        ofs<<buffer[15];
        /* Ce qui fait que le fichier ne le sera plus la prochaine fois */
        empty=false;
    }
    /* écrivons le reste des informations */
    ofs<<buffer[4]<<" "<<buffer[5]<<" "<<buffer[6]<<" "
       <<buffer[9]<<" "<<buffer[9]/10<<" "<<buffer[10]/10<<" "
       <<buffer[11]/10<<" "<<buffer[14];
    /* Si boucle il y a, elle termine sans doute ici */
  return 0;
}

[EDIT]A la base, le sujet était dans le forum C++... Il va de soi que tout ce que j'ai écris ici n'est valide que... pour le C++.

Si tu veux coder en C, fais moi signe, de manière à ce que je supprime cette intervention (qui n'a pas sa place)

Si tu veux coder en C++, signale le aussi, que l'on puisse remettre la discussion dans le bon forum

[petitclem]

Merci bien Davidbrcz, mais ça ne fonctionne toujours pas : ça m'écris par exemple buf[0] + la suite, puis buf[0] + la suite ...

Alors que ça devrait créer le fichier (vide), inscrire buf[0]+ suite puis suite, puis suite ...

[orfix]

OK, et bien un fichier de type texte avec pas encore de données inscrites à l'intérieur !
<...>

Alors, une fonction faite maison peut convenir :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
 
int isEmptyFile( char const *path )
{
	FILE *p_file=fopen( path , "r" );	 
	int ret=-1;
 
	if( p_file )
	{
		fseek( p_file, 0, SEEK_END );
		ret = ftell( p_file );
		fclose( p_file );
	}
	return ret;
}

L'appel sera un truc du genre :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
 
#include <stdio.h>
#include <stdlib.h>
 
#define FILENAME "Mon_Fichier.txt" 
int isEmptyFile( char const *path );
 
int main( void )
{
 
	switch( isEmptyFile( FILENAME ) )
	{
		case 0  : printf("'%s' est vide\n",FILENAME);
				  break;
		case -1 : printf("Erreur ...");
				  break;
		default : printf("'%s' n'est pas vide\n",FILENAME);
	}
	return 0;
}

@++


EDIT : pas besoin de spécifier le mode en paramétres de la fonction

[Davidbrcz]

Avec "r" en mode d'ouverture, j'ai supposé que le fichier existait déjà.
S'il faut le créer car il n'existe pas, le mode d'ouverture a+ est plus approprié (lecture/écriture en ajout à la fin) mais il impose après l'ouverture du fichier un rewind sur ce dernier (pour revenir au début).

[petitclem]

Oui mon fichier est créé avec le mode "a+", mais si je fais un rewind () il va écrire les dernières valeurs au début ?

[Davidbrcz]

bah oui, rewind envoie le curseur au début du fichier. C'est son rôle.

[petitclem]

OK, et bien c'est agaçant car maintenant cela me fait : buf[0] + suite et c'est tout alors que d'autres mesures sont effectués derrière !