Discussion :

[nicolas66]

Bonjour,

Dans le cadre d'un projet, je dois écrire un programme C++ pour lire un fichier par blocs de 9 caractères. J'ai trouvé la solution suivante :

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
 
#include <iostream>
#include <fstream>
#include <cstdlib>
#include <cstdio>
 
 
int main( int argc, char ** argv )
{
	std::ifstream Input("file.txt");
 
	if( !Input )
		return EXIT_FAILURE;
 
	char Block[10];
 
	while( Input.good() )
	{
		memset(Block, 0, 10);
		Input.read(Block, 9);
		std::cout << Block << std::endl;
	}
 
	Input.close();
 
	return EXIT_SUCCESS;
}

Cette solution a l'air de bien fonctionner. Cependant, je voudrai avoir votre avis sur d'éventuelles erreurs et si quelqu'un aurait une solution plus élégante à me proposer en utilisant par exemple la STL de manière plus efficace. Merci d'avance


Nico.

[Luc Hermitte]

* Ben .. la boucle de lecture est incorrecte. good, ce n'est pas mieux qu'eof !
* Les constantes magiques, c'est rarement conseillé.

Code :

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

1
2
3
4
5
6
7
const int BLOCK_SIZE = 9;
char block[BLOCK_SIZE + 1] = {0};
//     +1 => feinte pour le 0 terminal utilisé par le cout, sans intérêt autrement
while( input.read(block, BLOCK_SIZE ) )
{
    std::cout << block << std::endl;
}

Il faudrait rajouter des tests pour savoir quelle quantité de données a vraiment été lue. => readsome()

NB: en général, les Majuscules sont réservées aux types en C&C++.

[nicolas66]

- En fait j'ai commencé par la version que tu m'as filé en mettant l'appel à la fonction read directement dans le test du while. Cependant, je me trouve face à un problème : le dernier bloc est inférieur à 9 caractères et le bloc est zappé. J'ai donc temporairement changé la structure de la boucle en faisant appel à la fonction good.

- Concernant les nombres magiques, ils le sont simplement dans l'exemple ci-dessus, pas dans mon programme.

Pour le reste, je prends note . Sinon, n'y aurait-il pas moyen de mieux utiliser la STL ?

[Luc Hermitte]

Et donc, tu ne vas pas correctement lire la fin de ton fichier. good, contrairement à ce que son nom pourrait nous faire croire, ce n'est pas si bon que cela.
=> readsome.

Ici, on n'utilise pas la STL -- les flux sont dans la SL, pas la STL.
Sinon,
- il y a un très bon bouquin de Kreft et Langer sur les flux
- 9, c'est pas tip-top efficace pour une lecture bufferisée
- il y a une autre solution qui consiste à taper directement dans les streambuf. Jean Marc en parlait dans un autre fil ces jours-ci. Le fil sur l'unicode peut-être ?

[nicolas66]

Et donc, tu ne vas pas correctement lire la fin de ton fichier. good, contrairement à ce que son nom pourrait nous faire croire, ce n'est pas si bon que cela.
=> readsome.

Je suis au courant que good n'est pas la panacée. Je l'ai utilisé car je ne parvenais pas au résultat sans l'utiliser. Mais comment se fait-il alors que cela fonctionne dans mon cas ?

Pour le reste, je vais essayer de me renseigner

[dj.motte]

Bonjour,

Voiçi de l' info qui me paraît obscure :

Unformatted Input Functions
All the unformatted input functions have some common behavior. Each starts by constructing a temporary object of type std::basic_istream::sentry with the second argument (noskipws) set to true. This has several effects, concluding with the setting of a status flag; see the sentry documentation for more.

If the sentry status is good, the function tries to extract whatever data is appropriate for the type of the argument.

The number of characters extracted is stored for later retrieval by gcount().

If an exception is thrown during extraction, ios_base::badbit will be turned on in the stream's error state without causing an ios_base::failure to be thrown. The original exception will then be rethrown.

* __istream_type & get (__streambuf_type &__sb)
* __istream_type & get (__streambuf_type &__sb, char_type __delim)
* __istream_type & get (char_type *__s, streamsize __n)
* __istream_type & get (char_type *__s, streamsize __n, char_type __delim)
* __istream_type & get (char_type &__c)
* int_type get ()
* __istream_type & getline (char_type *__s, streamsize __n)
* __istream_type & getline (char_type *__s, streamsize __n, char_type __delim)
* __istream_type & ignore (streamsize __n, int_type __delim)
* __istream_type & ignore (streamsize __n)
* __istream_type & ignore ()
* int_type peek ()
* __istream_type & putback (char_type __c)
* __istream_type & read (char_type *__s, streamsize __n)
* streamsize readsome (char_type *__s, streamsize __n)
* __istream_type & seekg (off_type, ios_base::seekdir)
* __istream_type & seekg (pos_type)
* int sync ()
* pos_type tellg ()
* __istream_type & unget ()

* operator void * () const
* bool operator! () const

A vrai dire je ne sais pas ce que renvoit __istream_type ?
J' ai cherché sa définition, mais sans succés...

Salut.

[Luc Hermitte]

Mais comment se fait-il alors que cela fonctionne dans mon cas ?

Va vite jouer au loto.
Si le read foire, le contenu du buffer est à priori indéterminé. Or on ne peut pas savoir si il foire sans tester le flux après lecture.
Je trouve surprenant que tu obtiennes tes n (!=9) derniers caractères suivis d'un 0-terminal.

A vrai dire je ne sais pas ce que renvoit __istream_type ?

Double underscore en préfixe ? C'est une spécificité d'implémentation propre à la bibliothèque dont tu as trouvé cet extrait de documentation. Il s'agit très probablement d'un alias ou équivalent au std::istream manipulé.

[nicolas66]

Bon, j'ai essayé de prendre en compte tes remarques :

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
 
#include <iostream>
#include <fstream>
#include <cstdlib>
 
 
int main( int argc, char ** argv )
{
	std::ifstream Input("crypto.txt");
 
	if( !Input )
		return EXIT_FAILURE;
 
	char Block[10] = {0};
 
	while( Input.readsome(Block, 9) )
	{
		std::cout << Block << std::endl;
		memset(Block, 0, 10);
	}
 
	Input.close();
 
	return EXIT_SUCCESS;
}

[dj.motte]

Bonjour,

Luc Hermitte écrit :

Double underscore en préfixe ? C'est une spécificité d'implémentation propre à la bibliothèque dont tu as trouvé cet extrait de documentation. Il s'agit très probablement d'un alias ou équivalent au std::istream manipulé.

Cher ami, vous ne répondez pas à la question. Double souligné en préfixe, ce n' est qu' une broutille dans l' obscurantisme linguistique...
Maintenant pour revenir au sujet __istream_type c' est quoi au juste ? Une façon de signifier quelque chose, mais quoi ?
SVP ne me dîtes pas que c' est moi qui ai manipulé cette syntaxe, qui s' exhibe dans la documentation officielle du C++ !

Salut.

[JolyLoic]

Bien cher condisciple, interpellé par votre interrogation, j'ai regardé la seule documentation qui ait un caractère officiel du C++, à savoir les Saintes Écritures du Standard Iso, et je suis en mesure de vous affirmer que les termes impies de "__istream_type" n'y sont jamais évoqués.

Le plus proche que j'ai pu trouver de votre prose païenne, c'est :

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
// 27.6.1.3 Unformatted input:
streamsize gcount() const;
int_type get();
basic_istream<charT,traits>& get(char_type& c);
basic_istream<charT,traits>& get(char_type* s, streamsize n);
basic_istream<charT,traits>& get(char_type* s, streamsize n,
char_type delim);
basic_istream<charT,traits>& get(basic_streambuf<char_type,traits>& sb);
basic_istream<charT,traits>& get(basic_streambuf<char_type,traits>& sb,
char_type delim);
basic_istream<charT,traits>& getline(char_type* s, streamsize n);
basic_istream<charT,traits>& getline(char_type* s, streamsize n,
char_type delim);
basic_istream<charT,traits>& ignore
(streamsize n = 1, int_type delim = traits::eof());
int_type peek();
basic_istream<charT,traits>& read (char_type* s, streamsize n);
streamsize readsome(char_type* s, streamsize n);
basic_istream<charT,traits>& putback(char_type c);
basic_istream<charT,traits>& unget();
int sync();
pos_type tellg();
basic_istream<charT,traits>& seekg(pos_type);
basic_istream<charT,traits>& seekg(off_type, ios_base::seekdir);

Avec comme définition préalable :

Code :

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

1
2
template <class charT, class traits = char_traits<charT> >
class basic_istream

Donc, cet __istream_type n'est qu'un type interne, défini pour les besoins d'une implémentation. Comme l'a cité Luc :

Il s'agit très probablement d'un alias ou équivalent au std::istream manipulé.

[Jean-Marc.Bourguet]

Et donc, tu ne vas pas correctement lire la fin de ton fichier. good, contrairement à ce que son nom pourrait nous faire croire, ce n'est pas si bon que cela.
=> readsome.

readsome utilise in_avail() pour borner le nombre de caractères lu. Ce qui peut ne pas être ce qui est désiré.

- il y a un très bon bouquin de Kreft et Langer sur les flux
- 9, c'est pas tip-top efficace pour une lecture bufferisée
- il y a une autre solution qui consiste à taper directement dans les streambuf. Jean Marc en parlait dans un autre fil ces jours-ci. Le fil sur l'unicode peut-être ?

L'avantage d'utiliser le streambuf, c'est qu'on a le nombre de caractères lus. Mais il est possible qu'on puisse aussi utiliser read() et gcount() pour avoir le résultat voulu. J'ai pris l'habitude du streambuf et de sgetn et chaque fois que je vois gcount() je me dis qu'il faudrait que je vérifie si ça résouds bien le problème ou pas. Mais je n'en prend pas la peine sur le moment.

[nicolas66]

L'avantage d'utiliser le streambuf, c'est qu'on a le nombre de caractères lus. Mais il est possible qu'on puisse aussi utiliser read() et gcount() pour avoir le résultat voulu. J'ai pris l'habitude du streambuf et de sgetn et chaque fois que je vois gcount() je me dis qu'il faudrait que je vérifie si ça résouds bien le problème ou pas. Mais je n'en prend pas la peine sur le moment.

Tu as un exemple sous la main d'un programme de lecture de fichiers utilisant les streambuf ?

[Jean-Marc.Bourguet]

Tu utilises is->rbuf()->sgetn à peu prêt comme tu utiliserais is->read à part que le résultat est le nombre de caractères lus. Il faut faire attention simplement à la gestion de la fin de fichier et des erreurs car les flags sur is ne sont pas placés.