Bonjour à tous,
Pour mes besoins j'ai défini une fonction write ainsi :
template<typename T>
void write( std::ofstream & Stream, T Value )
{
Stream.write( reinterpret_cast<char*>( &Value ), sizeof T );
}
void main()
{
std::ofstream OutFileStream;
OutFileStream.open( "test" );
int c = 10;
write( OutFileStream, c );
}
Je m'étonne qu'elle n'existe pas déjà dans la STL, ou même carrement en tant
que fonction membre de ofstream. Je pense plutôt que j'ai mal cherché.
Y'a-t-il un équivalent et si non pourquoi ?
Merci.
On Wed, 18 Aug 2004 11:55:34 +0200, "Aurélien REGAT-BARREL" :
Je m'étonne qu'elle n'existe pas déjà dans la STL
Dans la STL, c'est normal. Dans la SL, ça peut paraître étonnant au premier abord. Sauf si tu te poses la question : que fait ta fonction "write" exactement ? Je ne suis pas sûr que la norme donne beaucoup de garanties là-dessus. Donc, une telle fonction dans la bibliothèque standard n'aurait pas beaucoup de sens. Si maintenant tu sais ce que cette fonction fait pour les types que tu comptes utiliser et avec le compilo que tu utilises, tu peux la mettre dans ta propre bibliothèque personnelle. Mais avec la doc qui va bien, car ça sent un peu le soufre...
-- ;-)
On Wed, 18 Aug 2004 11:55:34 +0200, "Aurélien REGAT-BARREL"
<nospam-aregatba@yahoo.fr.invalid>:
Je m'étonne qu'elle n'existe pas déjà dans la STL
Dans la STL, c'est normal.
Dans la SL, ça peut paraître étonnant au premier abord. Sauf si tu te
poses la question : que fait ta fonction "write" exactement ? Je ne
suis pas sûr que la norme donne beaucoup de garanties là-dessus. Donc,
une telle fonction dans la bibliothèque standard n'aurait pas beaucoup
de sens.
Si maintenant tu sais ce que cette fonction fait pour les types que tu
comptes utiliser et avec le compilo que tu utilises, tu peux la mettre
dans ta propre bibliothèque personnelle. Mais avec la doc qui va bien,
car ça sent un peu le soufre...
On Wed, 18 Aug 2004 11:55:34 +0200, "Aurélien REGAT-BARREL" :
Je m'étonne qu'elle n'existe pas déjà dans la STL
Dans la STL, c'est normal. Dans la SL, ça peut paraître étonnant au premier abord. Sauf si tu te poses la question : que fait ta fonction "write" exactement ? Je ne suis pas sûr que la norme donne beaucoup de garanties là-dessus. Donc, une telle fonction dans la bibliothèque standard n'aurait pas beaucoup de sens. Si maintenant tu sais ce que cette fonction fait pour les types que tu comptes utiliser et avec le compilo que tu utilises, tu peux la mettre dans ta propre bibliothèque personnelle. Mais avec la doc qui va bien, car ça sent un peu le soufre...
-- ;-)
Fabien LE LEZ
On Wed, 18 Aug 2004 11:55:34 +0200, "Aurélien REGAT-BARREL" :
template<typename T> void write( std::ofstream & Stream, T Value )
Typiquement, on écrira plutôt "... ostream ...". Pourquoi limiter la fonction aux seuls ofstream ?
-- ;-)
On Wed, 18 Aug 2004 11:55:34 +0200, "Aurélien REGAT-BARREL"
<nospam-aregatba@yahoo.fr.invalid>:
template<typename T>
void write( std::ofstream & Stream, T Value )
Typiquement, on écrira plutôt "... ostream ...". Pourquoi limiter la
fonction aux seuls ofstream ?
On Wed, 18 Aug 2004 11:55:34 +0200, "Aurélien REGAT-BARREL" :
template<typename T> void write( std::ofstream & Stream, T Value )
Typiquement, on écrira plutôt "... ostream ...". Pourquoi limiter la fonction aux seuls ofstream ?
-- ;-)
Aurélien REGAT-BARREL
Dans la SL, ça peut paraître étonnant au premier abord. Sauf si tu te poses la question : que fait ta fonction "write" exactement ? Je ne suis pas sûr que la norme donne beaucoup de garanties là-dessus. Donc, une telle fonction dans la bibliothèque standard n'aurait pas beaucoup de sens.
J'aurais une question simple alors : quelle est la méthode préconisée pour écrire disons un int dans un fichier, sous forme binaire (disons 4 octets). Je ne connais que celle-ci :
int n = 10; mon_ofstream.write( reinterpret_cast<char*>( &n ), sizeof n );
Je trouve ça, comment dire, aberrant :-) J'aurais bien vu quelque chose comme :
mon_ofstream << ios_base::binary << n;
Pour moi ios_base::binary veut bien dire ce qu'il veut dire : on est en mode binaire. Mais operator<< s'en fout et écrit une chaine de caractères...
-- Aurélien REGAT-BARREL
Dans la SL, ça peut paraître étonnant au premier abord. Sauf si tu te
poses la question : que fait ta fonction "write" exactement ? Je ne
suis pas sûr que la norme donne beaucoup de garanties là-dessus. Donc,
une telle fonction dans la bibliothèque standard n'aurait pas beaucoup
de sens.
J'aurais une question simple alors : quelle est la méthode préconisée pour
écrire disons un int dans un fichier, sous forme binaire (disons 4 octets).
Je ne connais que celle-ci :
int n = 10;
mon_ofstream.write( reinterpret_cast<char*>( &n ), sizeof n );
Je trouve ça, comment dire, aberrant :-)
J'aurais bien vu quelque chose comme :
mon_ofstream << ios_base::binary << n;
Pour moi ios_base::binary veut bien dire ce qu'il veut dire : on est en mode
binaire. Mais operator<< s'en fout et écrit une chaine de caractères...
Dans la SL, ça peut paraître étonnant au premier abord. Sauf si tu te poses la question : que fait ta fonction "write" exactement ? Je ne suis pas sûr que la norme donne beaucoup de garanties là-dessus. Donc, une telle fonction dans la bibliothèque standard n'aurait pas beaucoup de sens.
J'aurais une question simple alors : quelle est la méthode préconisée pour écrire disons un int dans un fichier, sous forme binaire (disons 4 octets). Je ne connais que celle-ci :
int n = 10; mon_ofstream.write( reinterpret_cast<char*>( &n ), sizeof n );
Je trouve ça, comment dire, aberrant :-) J'aurais bien vu quelque chose comme :
mon_ofstream << ios_base::binary << n;
Pour moi ios_base::binary veut bien dire ce qu'il veut dire : on est en mode binaire. Mais operator<< s'en fout et écrit une chaine de caractères...
-- Aurélien REGAT-BARREL
drkm
"Aurélien REGAT-BARREL" writes:
Dans la SL, ça peut paraître étonnant au premier abord. Sauf si tu te poses la question : que fait ta fonction "write" exactement ? Je ne suis pas sûr que la norme donne beaucoup de garanties là-dessus. Donc, une telle fonction dans la bibliothèque standard n'aurait pas beaucoup de sens.
J'aurais une question simple alors : quelle est la méthode préconisée pour écrire disons un int dans un fichier, sous forme binaire (disons 4 octets). Je ne connais que celle-ci :
int n = 10; mon_ofstream.write( reinterpret_cast<char*>( &n ), sizeof n );
Je trouve ça, comment dire, aberrant :-) J'aurais bien vu quelque chose comme :
mon_ofstream << ios_base::binary << n;
Pour moi ios_base::binary veut bien dire ce qu'il veut dire : on est en mode binaire. Mais operator<< s'en fout et écrit une chaine de caractères...
Parce que cela n'a aucun sens ?
Écrire en binaire ne veux pas dire grand-chose. Si tu veux pouvoir relire ce que tu as écrit, il faut que tu spécifies le format binaire exact de ton fichier. Et il faut alors que tu utilises std::ostream::write().
Non ?
--drkm, en recherche d'un stage : http://www.fgeorges.org/ipl/stage.html
Dans la SL, ça peut paraître étonnant au premier abord. Sauf si tu te
poses la question : que fait ta fonction "write" exactement ? Je ne
suis pas sûr que la norme donne beaucoup de garanties là-dessus. Donc,
une telle fonction dans la bibliothèque standard n'aurait pas beaucoup
de sens.
J'aurais une question simple alors : quelle est la méthode préconisée pour
écrire disons un int dans un fichier, sous forme binaire (disons 4 octets).
Je ne connais que celle-ci :
int n = 10;
mon_ofstream.write( reinterpret_cast<char*>( &n ), sizeof n );
Je trouve ça, comment dire, aberrant :-)
J'aurais bien vu quelque chose comme :
mon_ofstream << ios_base::binary << n;
Pour moi ios_base::binary veut bien dire ce qu'il veut dire : on est en mode
binaire. Mais operator<< s'en fout et écrit une chaine de caractères...
Parce que cela n'a aucun sens ?
Écrire en binaire ne veux pas dire grand-chose. Si tu veux pouvoir
relire ce que tu as écrit, il faut que tu spécifies le format binaire
exact de ton fichier. Et il faut alors que tu utilises
std::ostream::write().
Non ?
--drkm, en recherche d'un stage : http://www.fgeorges.org/ipl/stage.html
Dans la SL, ça peut paraître étonnant au premier abord. Sauf si tu te poses la question : que fait ta fonction "write" exactement ? Je ne suis pas sûr que la norme donne beaucoup de garanties là-dessus. Donc, une telle fonction dans la bibliothèque standard n'aurait pas beaucoup de sens.
J'aurais une question simple alors : quelle est la méthode préconisée pour écrire disons un int dans un fichier, sous forme binaire (disons 4 octets). Je ne connais que celle-ci :
int n = 10; mon_ofstream.write( reinterpret_cast<char*>( &n ), sizeof n );
Je trouve ça, comment dire, aberrant :-) J'aurais bien vu quelque chose comme :
mon_ofstream << ios_base::binary << n;
Pour moi ios_base::binary veut bien dire ce qu'il veut dire : on est en mode binaire. Mais operator<< s'en fout et écrit une chaine de caractères...
Parce que cela n'a aucun sens ?
Écrire en binaire ne veux pas dire grand-chose. Si tu veux pouvoir relire ce que tu as écrit, il faut que tu spécifies le format binaire exact de ton fichier. Et il faut alors que tu utilises std::ostream::write().
Non ?
--drkm, en recherche d'un stage : http://www.fgeorges.org/ipl/stage.html
kanze
"Aurélien REGAT-BARREL" wrote in message news:<41232669$0$29679$...
Pour mes besoins j'ai défini une fonction write ainsi :
template<typename T> void write( std::ofstream & Stream, T Value ) { Stream.write( reinterpret_cast<char*>( &Value ), sizeof T ); }
Je m'étonne qu'elle n'existe pas déjà dans la STL, ou même carrement en tant que fonction membre de ofstream. Je pense plutôt que j'ai mal cherché. Y'a-t-il un équivalent et si non pourquoi ?
Pas à ce que je sache ? À quoi peut-elle servir, à part écrire des données que personne ne pourra lire par la suite ?
-- James Kanze GABI Software http://www.gabi-soft.fr Conseils en informatique orientée objet/ Beratung in objektorientierter Datenverarbeitung 9 place Sémard, 78210 St.-Cyr-l'École, France, +33 (0)1 30 23 00 34
"Aurélien REGAT-BARREL" <nospam-aregatba@yahoo.fr.invalid> wrote in
message news:<41232669$0$29679$636a15ce@news.free.fr>...
Pour mes besoins j'ai défini une fonction write ainsi :
template<typename T>
void write( std::ofstream & Stream, T Value )
{
Stream.write( reinterpret_cast<char*>( &Value ), sizeof T );
}
Je m'étonne qu'elle n'existe pas déjà dans la STL, ou même carrement
en tant que fonction membre de ofstream. Je pense plutôt que j'ai mal
cherché. Y'a-t-il un équivalent et si non pourquoi ?
Pas à ce que je sache ? À quoi peut-elle servir, à part écrire des
données que personne ne pourra lire par la suite ?
--
James Kanze GABI Software http://www.gabi-soft.fr
Conseils en informatique orientée objet/
Beratung in objektorientierter Datenverarbeitung
9 place Sémard, 78210 St.-Cyr-l'École, France, +33 (0)1 30 23 00 34
"Aurélien REGAT-BARREL" wrote in message news:<41232669$0$29679$...
Pour mes besoins j'ai défini une fonction write ainsi :
template<typename T> void write( std::ofstream & Stream, T Value ) { Stream.write( reinterpret_cast<char*>( &Value ), sizeof T ); }
Je m'étonne qu'elle n'existe pas déjà dans la STL, ou même carrement en tant que fonction membre de ofstream. Je pense plutôt que j'ai mal cherché. Y'a-t-il un équivalent et si non pourquoi ?
Pas à ce que je sache ? À quoi peut-elle servir, à part écrire des données que personne ne pourra lire par la suite ?
-- James Kanze GABI Software http://www.gabi-soft.fr Conseils en informatique orientée objet/ Beratung in objektorientierter Datenverarbeitung 9 place Sémard, 78210 St.-Cyr-l'École, France, +33 (0)1 30 23 00 34
Falk Tannhäuser
Aurélien REGAT-BARREL wrote:
Dans la SL, ça peut paraître étonnant au premier abord. Sauf si tu te poses la question : que fait ta fonction "write" exactement ? Je ne suis pas sûr que la norme donne beaucoup de garanties là-dessus. Donc, une telle fonction dans la bibliothèque standard n'aurait pas beaucoup de sens.
J'aurais une question simple alors : quelle est la méthode préconisée pour écrire disons un int dans un fichier, sous forme binaire (disons 4 octets). Je ne connais que celle-ci :
int n = 10; mon_ofstream.write( reinterpret_cast<char*>( &n ), sizeof n );
Si tu fais ça, c'est que tu veux certainement relire l'entier plus tard et retrouver la même valeur ? (Sinon je ne sais pas à quoi ça sert d'écrire la variable dans un fichier :-}) Cela marchera bien tant que la relecture se fait sur la même machine sous le même OS avec un programme compilé avec le même compilateur, la même version, les mêmes options de compilation, lorsqu'il y avait la même température ambiante, pression atmosphérique, humidité relative et phase lunaire à la compilation, ... bref - ce n'est pas portable ! Dans le cas d'un int, peuvent varier : - la taille occupée en mémoire, - le nombre de bits utilisé pour la représentation, - l'ordre des bits (little endian, big endian, middle endian), - la façon de représenter les nombres négatifs (complément à 2, complément à 1, signe + magnitude)
Voir la discussion intitulée "Socket Java et C++" dans ce groupe, et notamment le message posté par James Kanze le 16/08/2004 à 12h12 pour avoir une idée de ce qu'il faudrait faire.
Je trouve ça, comment dire, aberrant :-) J'aurais bien vu quelque chose comme :
mon_ofstream << ios_base::binary << n;
Pour moi ios_base::binary veut bien dire ce qu'il veut dire : on est en mode binaire. Mais operator<< s'en fout et écrit une chaine de caractères...
Le mode 'binary' est bien nécessaire - le mieux est de le spécifier dés la construction : std::ofstream mon_ofstream("FileName.bin", std::ios::binary); Cela sert - en fonction du système - par exemple à empêcher certaines conversions (genre "n" vers "rn") qui ont lieu en mode texte.
Falk
Aurélien REGAT-BARREL wrote:
Dans la SL, ça peut paraître étonnant au premier abord. Sauf si tu te
poses la question : que fait ta fonction "write" exactement ? Je ne
suis pas sûr que la norme donne beaucoup de garanties là-dessus. Donc,
une telle fonction dans la bibliothèque standard n'aurait pas beaucoup
de sens.
J'aurais une question simple alors : quelle est la méthode préconisée pour
écrire disons un int dans un fichier, sous forme binaire (disons 4 octets).
Je ne connais que celle-ci :
int n = 10;
mon_ofstream.write( reinterpret_cast<char*>( &n ), sizeof n );
Si tu fais ça, c'est que tu veux certainement relire l'entier plus tard
et retrouver la même valeur ? (Sinon je ne sais pas à quoi ça sert d'écrire
la variable dans un fichier :-})
Cela marchera bien tant que la relecture se fait sur la même machine sous
le même OS avec un programme compilé avec le même compilateur, la même version,
les mêmes options de compilation, lorsqu'il y avait la même température ambiante,
pression atmosphérique, humidité relative et phase lunaire à la compilation, ...
bref - ce n'est pas portable !
Dans le cas d'un int, peuvent varier :
- la taille occupée en mémoire,
- le nombre de bits utilisé pour la représentation,
- l'ordre des bits (little endian, big endian, middle endian),
- la façon de représenter les nombres négatifs (complément à 2, complément
à 1, signe + magnitude)
Voir la discussion intitulée "Socket Java et C++" dans ce groupe, et
notamment le message <d6652001.0408160212.52dc995a@posting.google.com>
posté par James Kanze le 16/08/2004 à 12h12 pour avoir une idée de
ce qu'il faudrait faire.
Je trouve ça, comment dire, aberrant :-)
J'aurais bien vu quelque chose comme :
mon_ofstream << ios_base::binary << n;
Pour moi ios_base::binary veut bien dire ce qu'il veut dire : on est en mode
binaire. Mais operator<< s'en fout et écrit une chaine de caractères...
Le mode 'binary' est bien nécessaire - le mieux est de le spécifier
dés la construction :
std::ofstream mon_ofstream("FileName.bin", std::ios::binary);
Cela sert - en fonction du système - par exemple à empêcher certaines
conversions (genre "n" vers "rn") qui ont lieu en mode texte.
Dans la SL, ça peut paraître étonnant au premier abord. Sauf si tu te poses la question : que fait ta fonction "write" exactement ? Je ne suis pas sûr que la norme donne beaucoup de garanties là-dessus. Donc, une telle fonction dans la bibliothèque standard n'aurait pas beaucoup de sens.
J'aurais une question simple alors : quelle est la méthode préconisée pour écrire disons un int dans un fichier, sous forme binaire (disons 4 octets). Je ne connais que celle-ci :
int n = 10; mon_ofstream.write( reinterpret_cast<char*>( &n ), sizeof n );
Si tu fais ça, c'est que tu veux certainement relire l'entier plus tard et retrouver la même valeur ? (Sinon je ne sais pas à quoi ça sert d'écrire la variable dans un fichier :-}) Cela marchera bien tant que la relecture se fait sur la même machine sous le même OS avec un programme compilé avec le même compilateur, la même version, les mêmes options de compilation, lorsqu'il y avait la même température ambiante, pression atmosphérique, humidité relative et phase lunaire à la compilation, ... bref - ce n'est pas portable ! Dans le cas d'un int, peuvent varier : - la taille occupée en mémoire, - le nombre de bits utilisé pour la représentation, - l'ordre des bits (little endian, big endian, middle endian), - la façon de représenter les nombres négatifs (complément à 2, complément à 1, signe + magnitude)
Voir la discussion intitulée "Socket Java et C++" dans ce groupe, et notamment le message posté par James Kanze le 16/08/2004 à 12h12 pour avoir une idée de ce qu'il faudrait faire.
Je trouve ça, comment dire, aberrant :-) J'aurais bien vu quelque chose comme :
mon_ofstream << ios_base::binary << n;
Pour moi ios_base::binary veut bien dire ce qu'il veut dire : on est en mode binaire. Mais operator<< s'en fout et écrit une chaine de caractères...
Le mode 'binary' est bien nécessaire - le mieux est de le spécifier dés la construction : std::ofstream mon_ofstream("FileName.bin", std::ios::binary); Cela sert - en fonction du système - par exemple à empêcher certaines conversions (genre "n" vers "rn") qui ont lieu en mode texte.
Falk
Fabien LE LEZ
On Wed, 18 Aug 2004 17:39:39 +0200, "Aurélien REGAT-BARREL" :
J'aurais une question simple alors : quelle est la méthode préconisée pour écrire disons un int dans un fichier, sous forme binaire (disons 4 octets).
Sur un système précis, mettons, un PC sous Windows, et pour un type assez simple comme int, ta méthode fonctionne.
Si je veux définir un format de fichier précis, mettons, little-endian avec entiers sur 4 octets, avec un minimum de portabilité, j'écrirais unsigned char par unsigned char.
Je ne suis pas un spécialiste, mais le code suivant ne devrait pas être trop loin de quelque chose de potable :
void EcrireEntier (unsigned int mon_entier) { static int const NB_BITS_PAR_OCTET= 8; static int const NB_OCTETS_PAR_INT= 4; for (int i=0; i<NB_OCTETS_PAR_INT; ++i) { os.put (static_cast<unsigned_char>(mon_entier)); mon_entier >>= NB_BITS_PAR_OCTET; } }
Bien entendu, on oublie totalement la notion de template.
-- ;-)
On Wed, 18 Aug 2004 17:39:39 +0200, "Aurélien REGAT-BARREL"
<nospam-aregatba@yahoo.fr.invalid>:
J'aurais une question simple alors : quelle est la méthode préconisée pour
écrire disons un int dans un fichier, sous forme binaire (disons 4 octets).
Sur un système précis, mettons, un PC sous Windows, et pour un type
assez simple comme int, ta méthode fonctionne.
Si je veux définir un format de fichier précis, mettons, little-endian
avec entiers sur 4 octets, avec un minimum de portabilité, j'écrirais
unsigned char par unsigned char.
Je ne suis pas un spécialiste, mais le code suivant ne devrait pas
être trop loin de quelque chose de potable :
void EcrireEntier (unsigned int mon_entier)
{
static int const NB_BITS_PAR_OCTET= 8;
static int const NB_OCTETS_PAR_INT= 4;
for (int i=0; i<NB_OCTETS_PAR_INT; ++i)
{
os.put (static_cast<unsigned_char>(mon_entier));
mon_entier >>= NB_BITS_PAR_OCTET;
}
}
Bien entendu, on oublie totalement la notion de template.
On Wed, 18 Aug 2004 17:39:39 +0200, "Aurélien REGAT-BARREL" :
J'aurais une question simple alors : quelle est la méthode préconisée pour écrire disons un int dans un fichier, sous forme binaire (disons 4 octets).
Sur un système précis, mettons, un PC sous Windows, et pour un type assez simple comme int, ta méthode fonctionne.
Si je veux définir un format de fichier précis, mettons, little-endian avec entiers sur 4 octets, avec un minimum de portabilité, j'écrirais unsigned char par unsigned char.
Je ne suis pas un spécialiste, mais le code suivant ne devrait pas être trop loin de quelque chose de potable :
void EcrireEntier (unsigned int mon_entier) { static int const NB_BITS_PAR_OCTET= 8; static int const NB_OCTETS_PAR_INT= 4; for (int i=0; i<NB_OCTETS_PAR_INT; ++i) { os.put (static_cast<unsigned_char>(mon_entier)); mon_entier >>= NB_BITS_PAR_OCTET; } }
Bien entendu, on oublie totalement la notion de template.
Probablement parce que faire cela est aberrant aux yeux de ceux qui ont fait la SL... Si tu comprends pourquoi, que tu acceptes les limitations de la chose, que c'est vraiment ce que tu veux faire alors tout est correct et ce n'est pas plus aberrant que les autres emplois des autres ..._cast, tout aussi voyants.
-- Michel Michaud http://www.gdzid.com FAQ de fr.comp.lang.c++ : http://www.cmla.ens-cachan.fr/~dosreis/C++/FAQ/
Dans news:41237710$0$29677$636a15ce@news.free.fr, Aurélien
Probablement parce que faire cela est aberrant aux yeux de ceux
qui ont fait la SL... Si tu comprends pourquoi, que tu acceptes
les limitations de la chose, que c'est vraiment ce que tu veux
faire alors tout est correct et ce n'est pas plus aberrant que
les autres emplois des autres ..._cast, tout aussi voyants.
--
Michel Michaud mm@gdzid.com
http://www.gdzid.com
FAQ de fr.comp.lang.c++ :
http://www.cmla.ens-cachan.fr/~dosreis/C++/FAQ/
Probablement parce que faire cela est aberrant aux yeux de ceux qui ont fait la SL... Si tu comprends pourquoi, que tu acceptes les limitations de la chose, que c'est vraiment ce que tu veux faire alors tout est correct et ce n'est pas plus aberrant que les autres emplois des autres ..._cast, tout aussi voyants.
-- Michel Michaud http://www.gdzid.com FAQ de fr.comp.lang.c++ : http://www.cmla.ens-cachan.fr/~dosreis/C++/FAQ/
kanze
"Aurélien REGAT-BARREL" wrote in message news:<41237710$0$29677$...
Dans la SL, ça peut paraître étonnant au premier abord. Sauf si tu te poses la question : que fait ta fonction "write" exactement ? Je ne suis pas sûr que la norme donne beaucoup de garanties là-dessus. Donc, une telle fonction dans la bibliothèque standard n'aurait pas beaucoup de sens.
J'aurais une question simple alors : quelle est la méthode préconisée pour écrire disons un int dans un fichier, sous forme binaire (disons 4 octets).
Ça dépend du format voulu dans le fichier.
Je ne connais que celle-ci :
int n = 10; mon_ofstream.write( reinterpret_cast<char*>( &n ), sizeof n );
Qui ne marche en général pas. En fait, elle ne marche que si par hazard, le format du fichier et le format interne des données sont identiques. A priori, il n'y a aucune raison de croire que c'est le cas.
Je trouve ça, comment dire, aberrant :-) J'aurais bien vu quelque chose comme :
mon_ofstream << ios_base::binary << n;
Moi aussi. Pour sortir quelque chose du genre « 1001 » si n contenait 9, par exemple.
Pour moi ios_base::binary veut bien dire ce qu'il veut dire : on est en mode binaire. Mais operator<< s'en fout et écrit une chaine de caractères...
La définition de l'opérateur <<, c'est de formatter une valeur pour sortie. La définition de ostream, c'est de gérer des formats texte. Je ne vois rien là dedans qui autoriserait un format non textuel.
Pour des formats binaires, c'est assez courant de définir des flux qui conviennent : oberstream, oxdrstream, etc. Vue le nombre de formats binaires différents, on n'a pas voulu en normaliser tous, et on n'a pas voulu en privilégier un non plus.
-- James Kanze GABI Software http://www.gabi-soft.fr Conseils en informatique orientée objet/ Beratung in objektorientierter Datenverarbeitung 9 place Sémard, 78210 St.-Cyr-l'École, France, +33 (0)1 30 23 00 34
"Aurélien REGAT-BARREL" <nospam-aregatba@yahoo.fr.invalid> wrote in
message news:<41237710$0$29677$636a15ce@news.free.fr>...
Dans la SL, ça peut paraître étonnant au premier abord. Sauf si tu
te poses la question : que fait ta fonction "write" exactement ? Je
ne suis pas sûr que la norme donne beaucoup de garanties là-dessus.
Donc, une telle fonction dans la bibliothèque standard n'aurait pas
beaucoup de sens.
J'aurais une question simple alors : quelle est la méthode préconisée
pour écrire disons un int dans un fichier, sous forme binaire (disons
4 octets).
Ça dépend du format voulu dans le fichier.
Je ne connais que celle-ci :
int n = 10;
mon_ofstream.write( reinterpret_cast<char*>( &n ), sizeof n );
Qui ne marche en général pas. En fait, elle ne marche que si par hazard,
le format du fichier et le format interne des données sont identiques. A
priori, il n'y a aucune raison de croire que c'est le cas.
Je trouve ça, comment dire, aberrant :-) J'aurais bien vu quelque
chose comme :
mon_ofstream << ios_base::binary << n;
Moi aussi. Pour sortir quelque chose du genre « 1001 » si n contenait 9,
par exemple.
Pour moi ios_base::binary veut bien dire ce qu'il veut dire : on est
en mode binaire. Mais operator<< s'en fout et écrit une chaine de
caractères...
La définition de l'opérateur <<, c'est de formatter une valeur pour
sortie. La définition de ostream, c'est de gérer des formats texte. Je
ne vois rien là dedans qui autoriserait un format non textuel.
Pour des formats binaires, c'est assez courant de définir des flux qui
conviennent : oberstream, oxdrstream, etc. Vue le nombre de formats
binaires différents, on n'a pas voulu en normaliser tous, et on n'a pas
voulu en privilégier un non plus.
--
James Kanze GABI Software http://www.gabi-soft.fr
Conseils en informatique orientée objet/
Beratung in objektorientierter Datenverarbeitung
9 place Sémard, 78210 St.-Cyr-l'École, France, +33 (0)1 30 23 00 34
"Aurélien REGAT-BARREL" wrote in message news:<41237710$0$29677$...
Dans la SL, ça peut paraître étonnant au premier abord. Sauf si tu te poses la question : que fait ta fonction "write" exactement ? Je ne suis pas sûr que la norme donne beaucoup de garanties là-dessus. Donc, une telle fonction dans la bibliothèque standard n'aurait pas beaucoup de sens.
J'aurais une question simple alors : quelle est la méthode préconisée pour écrire disons un int dans un fichier, sous forme binaire (disons 4 octets).
Ça dépend du format voulu dans le fichier.
Je ne connais que celle-ci :
int n = 10; mon_ofstream.write( reinterpret_cast<char*>( &n ), sizeof n );
Qui ne marche en général pas. En fait, elle ne marche que si par hazard, le format du fichier et le format interne des données sont identiques. A priori, il n'y a aucune raison de croire que c'est le cas.
Je trouve ça, comment dire, aberrant :-) J'aurais bien vu quelque chose comme :
mon_ofstream << ios_base::binary << n;
Moi aussi. Pour sortir quelque chose du genre « 1001 » si n contenait 9, par exemple.
Pour moi ios_base::binary veut bien dire ce qu'il veut dire : on est en mode binaire. Mais operator<< s'en fout et écrit une chaine de caractères...
La définition de l'opérateur <<, c'est de formatter une valeur pour sortie. La définition de ostream, c'est de gérer des formats texte. Je ne vois rien là dedans qui autoriserait un format non textuel.
Pour des formats binaires, c'est assez courant de définir des flux qui conviennent : oberstream, oxdrstream, etc. Vue le nombre de formats binaires différents, on n'a pas voulu en normaliser tous, et on n'a pas voulu en privilégier un non plus.
-- James Kanze GABI Software http://www.gabi-soft.fr Conseils en informatique orientée objet/ Beratung in objektorientierter Datenverarbeitung 9 place Sémard, 78210 St.-Cyr-l'École, France, +33 (0)1 30 23 00 34
Aurélien REGAT-BARREL
Pour répondre à tout le monde, en fait ce qui me choque n'est pas tant l'absence de cette petite fonction template (j'ai maintenant bien compris pourquoi elle n'y est pas) que le fait que C++ impose l'utilisation de reinterpret_cast pour écrire une donnée en binaire. Cette fonction template avait juste pour but d'alléger l'écriture. fwrite accepte un void *, pourquoi ostream::write ne fait pas de même ?
-- Aurélien REGAT-BARREL
Pour répondre à tout le monde, en fait ce qui me choque n'est pas tant
l'absence de cette petite fonction template (j'ai maintenant bien compris
pourquoi elle n'y est pas) que le fait que C++ impose l'utilisation de
reinterpret_cast pour écrire une donnée en binaire. Cette fonction template
avait juste pour but d'alléger l'écriture.
fwrite accepte un void *, pourquoi ostream::write ne fait pas de même ?
Pour répondre à tout le monde, en fait ce qui me choque n'est pas tant l'absence de cette petite fonction template (j'ai maintenant bien compris pourquoi elle n'y est pas) que le fait que C++ impose l'utilisation de reinterpret_cast pour écrire une donnée en binaire. Cette fonction template avait juste pour but d'alléger l'écriture. fwrite accepte un void *, pourquoi ostream::write ne fait pas de même ?
