je ne sais pas trop quelle méthode choisir pour écrire/lire des chaînes
dans un fichier binaire
1) La première solution :
// pour écrire
// output est un std::fstream&
std::string UneChaine="coucou";
std::size_t len=UneChaine.size();
char const* contents=UneChaine.data();
output.write((char*)&len,sizeof(std::size_t));
output.write((char*)&contents,len);
// pour lire
// input est un std::fstream&
std::size_t len;
input.read((char*)&len,sizeof(std::size_t));
char *contents=new char[len+1];;
input.read((char*)&contents,len);
contents[len]=' ';
UneChaine=std::string(contents);
delete[] contents;
je trouve ça très lourd juste pour récupérer le contenu de la string
(j'ai l'impression de réserver 2 fois inutilement l'espace pour contenir la
chaîne !)
2) la deuxième solution
output << UneChaine
input >> UneChaine
c'est-à-dire que j'écris en mode texte dans mon fichier binaire (a priori,
ça devrait pas poser de problème ?)
Quels sont vos conseils ?
Quels sont les avantages/inconvénients de chaque méthode et est-il possible
d'améliorer la première ?
Merci à vous.
Marc
je ne sais pas trop quelle méthode choisir pour écrire/lire des chaînes
dans un fichier binaire
1) La première solution :
// pour écrire
// output est un std::fstream&
std::string UneChaine="coucou";
std::size_t len=UneChaine.size();
char const* contents=UneChaine.data();
output.write((char*)&len,sizeof(std::size_t));
output.write((char*)&contents,len);
// pour lire
// input est un std::fstream&
std::size_t len;
input.read((char*)&len,sizeof(std::size_t));
char *contents=new char[len+1];;
input.read((char*)&contents,len);
contents[len]=' ';
UneChaine=std::string(contents);
delete[] contents;
je trouve ça très lourd juste pour récupérer le contenu de la string
(j'ai l'impression de réserver 2 fois inutilement l'espace pour contenir la
chaîne !)
2) la deuxième solution
output << UneChaine
input >> UneChaine
c'est-à-dire que j'écris en mode texte dans mon fichier binaire (a priori,
ça devrait pas poser de problème ?)
Quels sont vos conseils ?
Quels sont les avantages/inconvénients de chaque méthode et est-il possible
d'améliorer la première ?
Merci à vous.
Marc
je ne sais pas trop quelle méthode choisir pour écrire/lire des chaînes
dans un fichier binaire
1) La première solution :
// pour écrire
// output est un std::fstream&
std::string UneChaine="coucou";
std::size_t len=UneChaine.size();
char const* contents=UneChaine.data();
output.write((char*)&len,sizeof(std::size_t));
output.write((char*)&contents,len);
// pour lire
// input est un std::fstream&
std::size_t len;
input.read((char*)&len,sizeof(std::size_t));
char *contents=new char[len+1];;
input.read((char*)&contents,len);
contents[len]=' ';
UneChaine=std::string(contents);
delete[] contents;
je trouve ça très lourd juste pour récupérer le contenu de la string
(j'ai l'impression de réserver 2 fois inutilement l'espace pour contenir la
chaîne !)
2) la deuxième solution
output << UneChaine
input >> UneChaine
c'est-à-dire que j'écris en mode texte dans mon fichier binaire (a priori,
ça devrait pas poser de problème ?)
Quels sont vos conseils ?
Quels sont les avantages/inconvénients de chaque méthode et est-il possible
d'améliorer la première ?
Merci à vous.
Marc
char const* contents=UneChaine.data();
output.write((char*)&len,sizeof(std::size_t));
output.write((char*)&contents,len);
char *contents=new char[len+1];;
input.read((char*)&contents,len);
contents[len]=' ';
UneChaine=std::string(contents);
output << UneChaine
input >> UneChaine
char const* contents=UneChaine.data();
output.write((char*)&len,sizeof(std::size_t));
output.write((char*)&contents,len);
char *contents=new char[len+1];;
input.read((char*)&contents,len);
contents[len]=' ';
UneChaine=std::string(contents);
output << UneChaine
input >> UneChaine
char const* contents=UneChaine.data();
output.write((char*)&len,sizeof(std::size_t));
output.write((char*)&contents,len);
char *contents=new char[len+1];;
input.read((char*)&contents,len);
contents[len]=' ';
UneChaine=std::string(contents);
output << UneChaine
input >> UneChaine
On Tue, 6 Nov 2007 14:18:00 +0100, "Marc G" :char const* contents=UneChaine.data();
output.write((char*)&len,sizeof(std::size_t));
Résultat indéfini : les octets seront bien écrits, mais on ne sait pas
dans quel ordre.
On Tue, 6 Nov 2007 14:18:00 +0100, "Marc G" <mgueguen@metrica.fr>:
char const* contents=UneChaine.data();
output.write((char*)&len,sizeof(std::size_t));
Résultat indéfini : les octets seront bien écrits, mais on ne sait pas
dans quel ordre.
On Tue, 6 Nov 2007 14:18:00 +0100, "Marc G" :char const* contents=UneChaine.data();
output.write((char*)&len,sizeof(std::size_t));
Résultat indéfini : les octets seront bien écrits, mais on ne sait pas
dans quel ordre.
char const* contents=UneChaine.data();
output.write((char*)&len,sizeof(std::size_t));
Résultat indéfini : les octets seront bien écrits, mais on ne sait pas
dans quel ordre.
J'ai l'impression que tu te trompes.
char const* contents=UneChaine.data();
output.write((char*)&len,sizeof(std::size_t));
Résultat indéfini : les octets seront bien écrits, mais on ne sait pas
dans quel ordre.
J'ai l'impression que tu te trompes.
char const* contents=UneChaine.data();
output.write((char*)&len,sizeof(std::size_t));
Résultat indéfini : les octets seront bien écrits, mais on ne sait pas
dans quel ordre.
J'ai l'impression que tu te trompes.
On 06 Nov 2007 14:47:26 +0100, Jean-Marc Bourguet :char const* contents=UneChaine.data();
output.write((char*)&len,sizeof(std::size_t));
Résultat indéfini : les octets seront bien écrits, mais on ne sait pas
dans quel ordre.
J'ai l'impression que tu te trompes.
Avec un compilateur précis sur une plate-forme précise, on peut savoir
dans quel ordre les octets seront écrits.
On 06 Nov 2007 14:47:26 +0100, Jean-Marc Bourguet <jm@bourguet.org>:
char const* contents=UneChaine.data();
output.write((char*)&len,sizeof(std::size_t));
Résultat indéfini : les octets seront bien écrits, mais on ne sait pas
dans quel ordre.
J'ai l'impression que tu te trompes.
Avec un compilateur précis sur une plate-forme précise, on peut savoir
dans quel ordre les octets seront écrits.
On 06 Nov 2007 14:47:26 +0100, Jean-Marc Bourguet :char const* contents=UneChaine.data();
output.write((char*)&len,sizeof(std::size_t));
Résultat indéfini : les octets seront bien écrits, mais on ne sait pas
dans quel ordre.
J'ai l'impression que tu te trompes.
Avec un compilateur précis sur une plate-forme précise, on peut savoir
dans quel ordre les octets seront écrits.
void EnregistreSizeT (ostream& os, size_t n)
{
static int const NB_OCTETS= 4; /* constante fixée une fois pour
toutes. */
for (int i=0; i<NB_OCTETS; ++i)
{
os.put (n & 255);
n >>= 8;
}
}
void EnregistreSizeT (ostream& os, size_t n)
{
static int const NB_OCTETS= 4; /* constante fixée une fois pour
toutes. */
for (int i=0; i<NB_OCTETS; ++i)
{
os.put (n & 255);
n >>= 8;
}
}
void EnregistreSizeT (ostream& os, size_t n)
{
static int const NB_OCTETS= 4; /* constante fixée une fois pour
toutes. */
for (int i=0; i<NB_OCTETS; ++i)
{
os.put (n & 255);
n >>= 8;
}
}
excuse-moi, je comprends pas bien comment tu vas utiliser cette fonction...
et comment je fais pour assurer la portabilité d'un système 32 bits vers un
système 64 bits ?
Qu'est-ce qui se passe avec ta fonction sur un systèrme 64 bits ? seuls les
32 bits de poids fort sont utilisés pour le codage des char, c'est ça ?
Et la ça me pose un autre problème !
Par exemple j'ai écrit/lu des bool comme ça :
output.write((char*)&missing_,sizeof(missing_)); // missing_ est un bool
input.read((char*)&missing_,sizeof(missing_));
Quelle est la portabilité de ce code ?
excuse-moi, je comprends pas bien comment tu vas utiliser cette fonction...
et comment je fais pour assurer la portabilité d'un système 32 bits vers un
système 64 bits ?
Qu'est-ce qui se passe avec ta fonction sur un systèrme 64 bits ? seuls les
32 bits de poids fort sont utilisés pour le codage des char, c'est ça ?
Et la ça me pose un autre problème !
Par exemple j'ai écrit/lu des bool comme ça :
output.write((char*)&missing_,sizeof(missing_)); // missing_ est un bool
input.read((char*)&missing_,sizeof(missing_));
Quelle est la portabilité de ce code ?
excuse-moi, je comprends pas bien comment tu vas utiliser cette fonction...
et comment je fais pour assurer la portabilité d'un système 32 bits vers un
système 64 bits ?
Qu'est-ce qui se passe avec ta fonction sur un systèrme 64 bits ? seuls les
32 bits de poids fort sont utilisés pour le codage des char, c'est ça ?
Et la ça me pose un autre problème !
Par exemple j'ai écrit/lu des bool comme ça :
output.write((char*)&missing_,sizeof(missing_)); // missing_ est un bool
input.read((char*)&missing_,sizeof(missing_));
Quelle est la portabilité de ce code ?
Et la ça me pose un autre problème !
Par exemple j'ai écrit/lu des bool comme ça :
output.write((char*)&missing_,sizeof(missing_)); // missing_ est un bool
input.read((char*)&missing_,sizeof(missing_));
Quelle est la portabilité de ce code ?
Gloups... Je n'en ai pas la moindre idée. La gestion en mémoire du
type "bool" est un peu un mystère pour moi, et je m'en porte très
bien.
Et la ça me pose un autre problème !
Par exemple j'ai écrit/lu des bool comme ça :
output.write((char*)&missing_,sizeof(missing_)); // missing_ est un bool
input.read((char*)&missing_,sizeof(missing_));
Quelle est la portabilité de ce code ?
Gloups... Je n'en ai pas la moindre idée. La gestion en mémoire du
type "bool" est un peu un mystère pour moi, et je m'en porte très
bien.
Et la ça me pose un autre problème !
Par exemple j'ai écrit/lu des bool comme ça :
output.write((char*)&missing_,sizeof(missing_)); // missing_ est un bool
input.read((char*)&missing_,sizeof(missing_));
Quelle est la portabilité de ce code ?
Gloups... Je n'en ai pas la moindre idée. La gestion en mémoire du
type "bool" est un peu un mystère pour moi, et je m'en porte très
bien.
"Marc G" writes:je ne sais pas trop quelle méthode choisir pour écrire/lire
des chaînes dans un fichier binaire
1) La première solution :
// pour écrire
// output est un std::fstream&
std::string UneChaine="coucou";
std::size_t len=UneChaine.size();
char const* contents=UneChaine.data();
output.write((char*)&len,sizeof(std::size_t));
output.write((char*)&contents,len);
// pour lire
// input est un std::fstream&
std::size_t len;
input.read((char*)&len,sizeof(std::size_t));
char *contents=new char[len+1];;
input.read((char*)&contents,len);
contents[len]=' ';
UneChaine=std::string(contents);
delete[] contents;
je trouve ça très lourd juste pour récupérer le contenu de
la string (j'ai l'impression de réserver 2 fois inutilement
l'espace pour contenir la chaîne !)
Tu peux faire un resize puis lire dans la UneChaine.data().
2) la deuxième solution
output << UneChaine
input >> UneChaine
c'est-à-dire que j'écris en mode texte dans mon fichier
binaire (a priori, ça devrait pas poser de problème ?)
S'il y a des blancs dans la chaine, si.
"Marc G" <mgueg...@metrica.fr> writes:
je ne sais pas trop quelle méthode choisir pour écrire/lire
des chaînes dans un fichier binaire
1) La première solution :
// pour écrire
// output est un std::fstream&
std::string UneChaine="coucou";
std::size_t len=UneChaine.size();
char const* contents=UneChaine.data();
output.write((char*)&len,sizeof(std::size_t));
output.write((char*)&contents,len);
// pour lire
// input est un std::fstream&
std::size_t len;
input.read((char*)&len,sizeof(std::size_t));
char *contents=new char[len+1];;
input.read((char*)&contents,len);
contents[len]=' ';
UneChaine=std::string(contents);
delete[] contents;
je trouve ça très lourd juste pour récupérer le contenu de
la string (j'ai l'impression de réserver 2 fois inutilement
l'espace pour contenir la chaîne !)
Tu peux faire un resize puis lire dans la UneChaine.data().
2) la deuxième solution
output << UneChaine
input >> UneChaine
c'est-à-dire que j'écris en mode texte dans mon fichier
binaire (a priori, ça devrait pas poser de problème ?)
S'il y a des blancs dans la chaine, si.
"Marc G" writes:je ne sais pas trop quelle méthode choisir pour écrire/lire
des chaînes dans un fichier binaire
1) La première solution :
// pour écrire
// output est un std::fstream&
std::string UneChaine="coucou";
std::size_t len=UneChaine.size();
char const* contents=UneChaine.data();
output.write((char*)&len,sizeof(std::size_t));
output.write((char*)&contents,len);
// pour lire
// input est un std::fstream&
std::size_t len;
input.read((char*)&len,sizeof(std::size_t));
char *contents=new char[len+1];;
input.read((char*)&contents,len);
contents[len]=' ';
UneChaine=std::string(contents);
delete[] contents;
je trouve ça très lourd juste pour récupérer le contenu de
la string (j'ai l'impression de réserver 2 fois inutilement
l'espace pour contenir la chaîne !)
Tu peux faire un resize puis lire dans la UneChaine.data().
2) la deuxième solution
output << UneChaine
input >> UneChaine
c'est-à-dire que j'écris en mode texte dans mon fichier
binaire (a priori, ça devrait pas poser de problème ?)
S'il y a des blancs dans la chaine, si.