Mais comme le vecteur peut avoir une taille importante (>10^9), je ne
voudrais pas l'avoir 2 fois en mémoire. En plus avec cette façon de
faire je devrais gérer la désallocation.
static const int N=4;
class Suite
{
vector<bitset<N> > *suite;
Mais comme le vecteur peut avoir une taille importante (>10^9), je ne
voudrais pas l'avoir 2 fois en mémoire. En plus avec cette façon de
faire je devrais gérer la désallocation.
static const int N=4;
class Suite
{
vector<bitset<N> > *suite;
Mais comme le vecteur peut avoir une taille importante (>10^9), je ne
voudrais pas l'avoir 2 fois en mémoire. En plus avec cette façon de
faire je devrais gérer la désallocation.
static const int N=4;
class Suite
{
vector<bitset<N> > *suite;
Mais comme le vecteur peut avoir une taille importante (>10^9), je ne
voudrais pas l'avoir 2 fois en mémoire. En plus avec cette façon de
faire je devrais gérer la désallocation.
Pourquoi ne pas créer un espace d'itérateur intelligent (une vue) qui
convertit les données en binaire au fur et à mesure qu'on les lit ?
Un pointeur intelligent, j'y ai pensé pour gérer la désallocation. J'ai
L'idéal, bien sûr, serait de pouvoir retourner directement un pointeur
vers toutes les données sans toucher à rien, mais je doute que bitset le
permette.
Oui ce serait parfait.
static const int N=4;
Pourquoi ne pas faire un argument template plutôt ?
Parce que c'est fixe. Si je ne me mélange pas les pinceaux, tu me
class Suite
{
vector<bitset<N> > *suite;
Pourquoi un pointeur ?
Là c'est juste pour ne pas avoir à utiliser suite.reserve(X) dans le
Mais comme le vecteur peut avoir une taille importante (>10^9), je ne
voudrais pas l'avoir 2 fois en mémoire. En plus avec cette façon de
faire je devrais gérer la désallocation.
Pourquoi ne pas créer un espace d'itérateur intelligent (une vue) qui
convertit les données en binaire au fur et à mesure qu'on les lit ?
Un pointeur intelligent, j'y ai pensé pour gérer la désallocation. J'ai
L'idéal, bien sûr, serait de pouvoir retourner directement un pointeur
vers toutes les données sans toucher à rien, mais je doute que bitset le
permette.
Oui ce serait parfait.
static const int N=4;
Pourquoi ne pas faire un argument template plutôt ?
Parce que c'est fixe. Si je ne me mélange pas les pinceaux, tu me
class Suite
{
vector<bitset<N> > *suite;
Pourquoi un pointeur ?
Là c'est juste pour ne pas avoir à utiliser suite.reserve(X) dans le
Mais comme le vecteur peut avoir une taille importante (>10^9), je ne
voudrais pas l'avoir 2 fois en mémoire. En plus avec cette façon de
faire je devrais gérer la désallocation.
Pourquoi ne pas créer un espace d'itérateur intelligent (une vue) qui
convertit les données en binaire au fur et à mesure qu'on les lit ?
Un pointeur intelligent, j'y ai pensé pour gérer la désallocation. J'ai
L'idéal, bien sûr, serait de pouvoir retourner directement un pointeur
vers toutes les données sans toucher à rien, mais je doute que bitset le
permette.
Oui ce serait parfait.
static const int N=4;
Pourquoi ne pas faire un argument template plutôt ?
Parce que c'est fixe. Si je ne me mélange pas les pinceaux, tu me
class Suite
{
vector<bitset<N> > *suite;
Pourquoi un pointeur ?
Là c'est juste pour ne pas avoir à utiliser suite.reserve(X) dans le
Un pointeur intelligent, j'y ai pensé pour gérer la désallocation. J'ai
vu celui de boost (boost::shared_ptr), mais je dois encore
l'apprivoiser, je ne connais pas.
Parce que c'est fixe. Si je ne me mélange pas les pinceaux, tu me
proposes d'écrire vector<bitset<T> > (à moins que ce soit vector<T> ?).
Mais je ne vois pas l'intérêt de faire ça, quelle autre classe utiliser
? Explique moi ce que je ne vois pas.
Là c'est juste pour ne pas avoir à utiliser suite.reserve(X) dans le
constructeur. Ça me parait plus "propre" d'instancier le vecteur
seulement lorsque je connais sa taille.
Un pointeur intelligent, j'y ai pensé pour gérer la désallocation. J'ai
vu celui de boost (boost::shared_ptr), mais je dois encore
l'apprivoiser, je ne connais pas.
Parce que c'est fixe. Si je ne me mélange pas les pinceaux, tu me
proposes d'écrire vector<bitset<T> > (à moins que ce soit vector<T> ?).
Mais je ne vois pas l'intérêt de faire ça, quelle autre classe utiliser
? Explique moi ce que je ne vois pas.
Là c'est juste pour ne pas avoir à utiliser suite.reserve(X) dans le
constructeur. Ça me parait plus "propre" d'instancier le vecteur
seulement lorsque je connais sa taille.
Un pointeur intelligent, j'y ai pensé pour gérer la désallocation. J'ai
vu celui de boost (boost::shared_ptr), mais je dois encore
l'apprivoiser, je ne connais pas.
Parce que c'est fixe. Si je ne me mélange pas les pinceaux, tu me
proposes d'écrire vector<bitset<T> > (à moins que ce soit vector<T> ?).
Mais je ne vois pas l'intérêt de faire ça, quelle autre classe utiliser
? Explique moi ce que je ne vois pas.
Là c'est juste pour ne pas avoir à utiliser suite.reserve(X) dans le
constructeur. Ça me parait plus "propre" d'instancier le vecteur
seulement lorsque je connais sa taille.
J'ai une classe qui contient un élément vector<bitset<N> > de
longueur variable. N est fixe. Je voudrais écrire le conteneur
de ce vecteur dans un fichier binaire.
Je pensais utiliser une fonction data() qui retournerait un
char*. Mais comme le vecteur peut avoir une taille importante
(>10^9), je ne voudrais pas l'avoir 2 fois en mémoire. En plus
avec cette façon de faire je devrais gérer la désallocation.
Ma question est donc : suis-je sur le droit chemin ? Suis-je
passé à côté d'une solution évidente/de la STL ?
J'ai une classe qui contient un élément vector<bitset<N> > de
longueur variable. N est fixe. Je voudrais écrire le conteneur
de ce vecteur dans un fichier binaire.
Je pensais utiliser une fonction data() qui retournerait un
char*. Mais comme le vecteur peut avoir une taille importante
(>10^9), je ne voudrais pas l'avoir 2 fois en mémoire. En plus
avec cette façon de faire je devrais gérer la désallocation.
Ma question est donc : suis-je sur le droit chemin ? Suis-je
passé à côté d'une solution évidente/de la STL ?
J'ai une classe qui contient un élément vector<bitset<N> > de
longueur variable. N est fixe. Je voudrais écrire le conteneur
de ce vecteur dans un fichier binaire.
Je pensais utiliser une fonction data() qui retournerait un
char*. Mais comme le vecteur peut avoir une taille importante
(>10^9), je ne voudrais pas l'avoir 2 fois en mémoire. En plus
avec cette façon de faire je devrais gérer la désallocation.
Ma question est donc : suis-je sur le droit chemin ? Suis-je
passé à côté d'une solution évidente/de la STL ?
Mais comme le vecteur peut avoir une taille importante
(>10^9), je ne voudrais pas l'avoir 2 fois en mémoire. En
plus avec cette façon de faire je devrais gérer la
désallocation.
Pourquoi ne pas créer un espace d'itérateur intelligent (une
vue) qui convertit les données en binaire au fur et à mesure
qu'on les lit ?
Un pointeur intelligent, j'y ai pensé pour gérer la
désallocation. J'ai vu celui de boost (boost::shared_ptr),
mais je dois encore l'apprivoiser, je ne connais pas.
L'idéal, bien sûr, serait de pouvoir retourner directement
un pointeur vers toutes les données sans toucher à rien,
mais je doute que bitset le permette.
Oui ce serait parfait.
static const int N=4;
Pourquoi ne pas faire un argument template plutôt ?
Parce que c'est fixe. Si je ne me mélange pas les pinceaux, tu
me proposes d'écrire vector<bitset<T> > (à moins que ce soit
vector<T> ?). Mais je ne vois pas l'intérêt de faire ça,
quelle autre classe utiliser ? Explique moi ce que je ne vois
pas.
class Suite
{
vector<bitset<N> > *suite;
Pourquoi un pointeur ?
Là c'est juste pour ne pas avoir à utiliser suite.reserve(X)
dans le constructeur. Ça me parait plus "propre" d'instancier
le vecteur seulement lorsque je connais sa taille.
Mais comme le vecteur peut avoir une taille importante
(>10^9), je ne voudrais pas l'avoir 2 fois en mémoire. En
plus avec cette façon de faire je devrais gérer la
désallocation.
Pourquoi ne pas créer un espace d'itérateur intelligent (une
vue) qui convertit les données en binaire au fur et à mesure
qu'on les lit ?
Un pointeur intelligent, j'y ai pensé pour gérer la
désallocation. J'ai vu celui de boost (boost::shared_ptr),
mais je dois encore l'apprivoiser, je ne connais pas.
L'idéal, bien sûr, serait de pouvoir retourner directement
un pointeur vers toutes les données sans toucher à rien,
mais je doute que bitset le permette.
Oui ce serait parfait.
static const int N=4;
Pourquoi ne pas faire un argument template plutôt ?
Parce que c'est fixe. Si je ne me mélange pas les pinceaux, tu
me proposes d'écrire vector<bitset<T> > (à moins que ce soit
vector<T> ?). Mais je ne vois pas l'intérêt de faire ça,
quelle autre classe utiliser ? Explique moi ce que je ne vois
pas.
class Suite
{
vector<bitset<N> > *suite;
Pourquoi un pointeur ?
Là c'est juste pour ne pas avoir à utiliser suite.reserve(X)
dans le constructeur. Ça me parait plus "propre" d'instancier
le vecteur seulement lorsque je connais sa taille.
Mais comme le vecteur peut avoir une taille importante
(>10^9), je ne voudrais pas l'avoir 2 fois en mémoire. En
plus avec cette façon de faire je devrais gérer la
désallocation.
Pourquoi ne pas créer un espace d'itérateur intelligent (une
vue) qui convertit les données en binaire au fur et à mesure
qu'on les lit ?
Un pointeur intelligent, j'y ai pensé pour gérer la
désallocation. J'ai vu celui de boost (boost::shared_ptr),
mais je dois encore l'apprivoiser, je ne connais pas.
L'idéal, bien sûr, serait de pouvoir retourner directement
un pointeur vers toutes les données sans toucher à rien,
mais je doute que bitset le permette.
Oui ce serait parfait.
static const int N=4;
Pourquoi ne pas faire un argument template plutôt ?
Parce que c'est fixe. Si je ne me mélange pas les pinceaux, tu
me proposes d'écrire vector<bitset<T> > (à moins que ce soit
vector<T> ?). Mais je ne vois pas l'intérêt de faire ça,
quelle autre classe utiliser ? Explique moi ce que je ne vois
pas.
class Suite
{
vector<bitset<N> > *suite;
Pourquoi un pointeur ?
Là c'est juste pour ne pas avoir à utiliser suite.reserve(X)
dans le constructeur. Ça me parait plus "propre" d'instancier
le vecteur seulement lorsque je connais sa taille.
Bonjour,
J'ai une classe qui contient un élément vector<bitset<N> > de longueur
variable. N est fixe. Je voudrais écrire le contenu de ce vecteur dans
un fichier binaire.
template <size_t N>
class Suite
{
vector<bitset<N> > suite;
...
};
et après tu créés ton instance avec Suite<4> ta_suite;
Je n'en ai pas l'intérêt. Je ne veux pas que l'utilisateur de la classe
La solution habituelle, c'est de créer des flux binaires, à la
modèle des flux de texte standard. Quelque chose comme
ibinstream et obinstream, par exmple. Typiquement, ces flux
deriveraient de std::ios (pour la gestion d'erreur et du
streambuf*), et délégueraient au std::streambuf pour les
entrées/sorties physiques.
Avec cette solution, l'utilisateur écrira quelque chose du
genre :
ofbstream dest( "nom_de_fichier" ) ;
if ( ! dest ) {
// Erreur de création...
}
dest << mesDonnees ;
L'opérateur << pourrait être quelque chose du genre :
obstream&
operator<<( obstream& dest, Suite const& source )
{
source.output( dest ) ;
return dest ;
}
Bonjour,
J'ai une classe qui contient un élément vector<bitset<N> > de longueur
variable. N est fixe. Je voudrais écrire le contenu de ce vecteur dans
un fichier binaire.
template <size_t N>
class Suite
{
vector<bitset<N> > suite;
...
};
et après tu créés ton instance avec Suite<4> ta_suite;
Je n'en ai pas l'intérêt. Je ne veux pas que l'utilisateur de la classe
La solution habituelle, c'est de créer des flux binaires, à la
modèle des flux de texte standard. Quelque chose comme
ibinstream et obinstream, par exmple. Typiquement, ces flux
deriveraient de std::ios (pour la gestion d'erreur et du
streambuf*), et délégueraient au std::streambuf pour les
entrées/sorties physiques.
Avec cette solution, l'utilisateur écrira quelque chose du
genre :
ofbstream dest( "nom_de_fichier" ) ;
if ( ! dest ) {
// Erreur de création...
}
dest << mesDonnees ;
L'opérateur << pourrait être quelque chose du genre :
obstream&
operator<<( obstream& dest, Suite const& source )
{
source.output( dest ) ;
return dest ;
}
Bonjour,
J'ai une classe qui contient un élément vector<bitset<N> > de longueur
variable. N est fixe. Je voudrais écrire le contenu de ce vecteur dans
un fichier binaire.
template <size_t N>
class Suite
{
vector<bitset<N> > suite;
...
};
et après tu créés ton instance avec Suite<4> ta_suite;
Je n'en ai pas l'intérêt. Je ne veux pas que l'utilisateur de la classe
La solution habituelle, c'est de créer des flux binaires, à la
modèle des flux de texte standard. Quelque chose comme
ibinstream et obinstream, par exmple. Typiquement, ces flux
deriveraient de std::ios (pour la gestion d'erreur et du
streambuf*), et délégueraient au std::streambuf pour les
entrées/sorties physiques.
Avec cette solution, l'utilisateur écrira quelque chose du
genre :
ofbstream dest( "nom_de_fichier" ) ;
if ( ! dest ) {
// Erreur de création...
}
dest << mesDonnees ;
L'opérateur << pourrait être quelque chose du genre :
obstream&
operator<<( obstream& dest, Suite const& source )
{
source.output( dest ) ;
return dest ;
}
Je vais reformuler un peu ce qui me tracasse.
Pour placer un vector<bitset> dans un 'truc' (flux, char*, int),
suis-je obligé de convertir un après l'autre tous les bitsets de mon
vecteur ? N'existe-t-il pas une façon toute faite de le transformer en
suite de 0 et de 1 ?
ou de transformer plusieurs bitsets d'un coup ?
(plus efficace que ((A<<1 + B)<<1 + C)<<1 +D = deux_octets avec A, B,
C, D des bitsets<4>.to_ulong() )
Non, il n'existe pas de solution toute faite. Mais dans ton cas (N = 4),
Je vais reformuler un peu ce qui me tracasse.
Pour placer un vector<bitset> dans un 'truc' (flux, char*, int),
suis-je obligé de convertir un après l'autre tous les bitsets de mon
vecteur ? N'existe-t-il pas une façon toute faite de le transformer en
suite de 0 et de 1 ?
ou de transformer plusieurs bitsets d'un coup ?
(plus efficace que ((A<<1 + B)<<1 + C)<<1 +D = deux_octets avec A, B,
C, D des bitsets<4>.to_ulong() )
Non, il n'existe pas de solution toute faite. Mais dans ton cas (N = 4),
Je vais reformuler un peu ce qui me tracasse.
Pour placer un vector<bitset> dans un 'truc' (flux, char*, int),
suis-je obligé de convertir un après l'autre tous les bitsets de mon
vecteur ? N'existe-t-il pas une façon toute faite de le transformer en
suite de 0 et de 1 ?
ou de transformer plusieurs bitsets d'un coup ?
(plus efficace que ((A<<1 + B)<<1 + C)<<1 +D = deux_octets avec A, B,
C, D des bitsets<4>.to_ulong() )
Non, il n'existe pas de solution toute faite. Mais dans ton cas (N = 4),
Je vais reformuler un peu ce qui me tracasse.
Pour placer un vector<bitset> dans un 'truc' (flux, char*, int),
suis-je obligé de convertir un après l'autre tous les bitsets de mon
vecteur ? N'existe-t-il pas une façon toute faite de le transformer en
suite de 0 et de 1 ?
ou de transformer plusieurs bitsets d'un coup ?
(plus efficace que ((A<<1 + B)<<1 + C)<<1 +D = deux_octets avec A, B,
C, D des bitsets<4>.to_ulong() )
Non, il n'existe pas de solution toute faite. Mais dans ton cas (N = 4),
c'est particulièrement simple, il suffit de grouper les bitsets 2 par 2
dans un octet :
Merci pour cette réponse.
Je vais reformuler un peu ce qui me tracasse.
Pour placer un vector<bitset> dans un 'truc' (flux, char*, int),
suis-je obligé de convertir un après l'autre tous les bitsets de mon
vecteur ? N'existe-t-il pas une façon toute faite de le transformer en
suite de 0 et de 1 ?
ou de transformer plusieurs bitsets d'un coup ?
(plus efficace que ((A<<1 + B)<<1 + C)<<1 +D = deux_octets avec A, B,
C, D des bitsets<4>.to_ulong() )
Non, il n'existe pas de solution toute faite. Mais dans ton cas (N = 4),
c'est particulièrement simple, il suffit de grouper les bitsets 2 par 2
dans un octet :
Merci pour cette réponse.
Je vais reformuler un peu ce qui me tracasse.
Pour placer un vector<bitset> dans un 'truc' (flux, char*, int),
suis-je obligé de convertir un après l'autre tous les bitsets de mon
vecteur ? N'existe-t-il pas une façon toute faite de le transformer en
suite de 0 et de 1 ?
ou de transformer plusieurs bitsets d'un coup ?
(plus efficace que ((A<<1 + B)<<1 + C)<<1 +D = deux_octets avec A, B,
C, D des bitsets<4>.to_ulong() )
Non, il n'existe pas de solution toute faite. Mais dans ton cas (N = 4),
c'est particulièrement simple, il suffit de grouper les bitsets 2 par 2
dans un octet :
Merci pour cette réponse.
La solution habituelle, c'est de créer des flux binaires, à la
modèle des flux de texte standard. Quelque chose comme
ibinstream et obinstream, par exmple. Typiquement, ces flux
deriveraient de std::ios (pour la gestion d'erreur et du
streambuf*), et délégueraient au std::streambuf pour les
entrées/sorties physiques.
Avec cette solution, l'utilisateur écrira quelque chose du
genre :
ofbstream dest( "nom_de_fichier" ) ;
if ( ! dest ) {
// Erreur de création...
}
dest << mesDonnees ;
L'opérateur << pourrait être quelque chose du genre :
obstream&
operator<<( obstream& dest, Suite const& source )
{
source.output( dest ) ;
return dest ;
}
Merci pour cette réponse, mais il me semble que le problème n'est que
déplacé. Dans ton exemple ce qui me pose problème maintenant c'est le
source.output(dest).
Que ce soit avec write ou avec les flux le problème est plutôt
de transformer un vector<bitset> en quelque chose qui peut se
mettre dans un fichier binaire avec un flux ou avec write.
Pour contrôler ma mémoire, il me semble qu'un bon compromis
est de prendre un tampon d'écriture (char* ou int) et
d'enregistrer mon vecteur "par morceaux".
Je vais reformuler un peu ce qui me tracasse.
Pour placer un vector<bitset> dans un 'truc' (flux, char*,
int), suis-je obligé de convertir un après l'autre tous les
bitsets de mon vecteur ?
N'existe-t-il pas une façon toute faite de le transformer en
suite de 0 et de 1 ?
ou de transformer plusieurs bitsets d'un coup ?
(plus efficace que ((A<<1 + B)<<1 + C)<<1 +D = deux_octets avec A, B, C,
D des bitsets<4>.to_ulong() )
La solution habituelle, c'est de créer des flux binaires, à la
modèle des flux de texte standard. Quelque chose comme
ibinstream et obinstream, par exmple. Typiquement, ces flux
deriveraient de std::ios (pour la gestion d'erreur et du
streambuf*), et délégueraient au std::streambuf pour les
entrées/sorties physiques.
Avec cette solution, l'utilisateur écrira quelque chose du
genre :
ofbstream dest( "nom_de_fichier" ) ;
if ( ! dest ) {
// Erreur de création...
}
dest << mesDonnees ;
L'opérateur << pourrait être quelque chose du genre :
obstream&
operator<<( obstream& dest, Suite const& source )
{
source.output( dest ) ;
return dest ;
}
Merci pour cette réponse, mais il me semble que le problème n'est que
déplacé. Dans ton exemple ce qui me pose problème maintenant c'est le
source.output(dest).
Que ce soit avec write ou avec les flux le problème est plutôt
de transformer un vector<bitset> en quelque chose qui peut se
mettre dans un fichier binaire avec un flux ou avec write.
Pour contrôler ma mémoire, il me semble qu'un bon compromis
est de prendre un tampon d'écriture (char* ou int) et
d'enregistrer mon vecteur "par morceaux".
Je vais reformuler un peu ce qui me tracasse.
Pour placer un vector<bitset> dans un 'truc' (flux, char*,
int), suis-je obligé de convertir un après l'autre tous les
bitsets de mon vecteur ?
N'existe-t-il pas une façon toute faite de le transformer en
suite de 0 et de 1 ?
ou de transformer plusieurs bitsets d'un coup ?
(plus efficace que ((A<<1 + B)<<1 + C)<<1 +D = deux_octets avec A, B, C,
D des bitsets<4>.to_ulong() )
La solution habituelle, c'est de créer des flux binaires, à la
modèle des flux de texte standard. Quelque chose comme
ibinstream et obinstream, par exmple. Typiquement, ces flux
deriveraient de std::ios (pour la gestion d'erreur et du
streambuf*), et délégueraient au std::streambuf pour les
entrées/sorties physiques.
Avec cette solution, l'utilisateur écrira quelque chose du
genre :
ofbstream dest( "nom_de_fichier" ) ;
if ( ! dest ) {
// Erreur de création...
}
dest << mesDonnees ;
L'opérateur << pourrait être quelque chose du genre :
obstream&
operator<<( obstream& dest, Suite const& source )
{
source.output( dest ) ;
return dest ;
}
Merci pour cette réponse, mais il me semble que le problème n'est que
déplacé. Dans ton exemple ce qui me pose problème maintenant c'est le
source.output(dest).
Que ce soit avec write ou avec les flux le problème est plutôt
de transformer un vector<bitset> en quelque chose qui peut se
mettre dans un fichier binaire avec un flux ou avec write.
Pour contrôler ma mémoire, il me semble qu'un bon compromis
est de prendre un tampon d'écriture (char* ou int) et
d'enregistrer mon vecteur "par morceaux".
Je vais reformuler un peu ce qui me tracasse.
Pour placer un vector<bitset> dans un 'truc' (flux, char*,
int), suis-je obligé de convertir un après l'autre tous les
bitsets de mon vecteur ?
N'existe-t-il pas une façon toute faite de le transformer en
suite de 0 et de 1 ?
ou de transformer plusieurs bitsets d'un coup ?
(plus efficace que ((A<<1 + B)<<1 + C)<<1 +D = deux_octets avec A, B, C,
D des bitsets<4>.to_ulong() )
Je vais reformuler un peu ce qui me tracasse. Pour placer un
vector<bitset> dans un 'truc' (flux, char*, int), suis-je
obligé de convertir un après l'autre tous les bitsets de mon
vecteur ? N'existe-t-il pas une façon toute faite de le
transformer en suite de 0 et de 1 ? ou de transformer
plusieurs bitsets d'un coup ? (plus efficace que ((A<<1 +
B)<<1 + C)<<1 +D = deux_octets avec A, B, C, D des
bitsets<4>.to_ulong() )
Non, il n'existe pas de solution toute faite. Mais dans ton
cas (N = 4), c'est particulièrement simple, il suffit de
grouper les bitsets 2 par 2 dans un octet :
std::ostream&
operator<<(std::ostream& dest,
std::vector< std::bitset<4> > const& source)
{
int i;
for(i = 0; i < source.size() - 1; i += 2)
{
dest.put(source[i].to_ulong() + (source[i + 1].to_ulong() <<
4));
}
if (i < source.size())
{
dest.put(source[i].to_ulong());
}
return dest;
}
Je vais reformuler un peu ce qui me tracasse. Pour placer un
vector<bitset> dans un 'truc' (flux, char*, int), suis-je
obligé de convertir un après l'autre tous les bitsets de mon
vecteur ? N'existe-t-il pas une façon toute faite de le
transformer en suite de 0 et de 1 ? ou de transformer
plusieurs bitsets d'un coup ? (plus efficace que ((A<<1 +
B)<<1 + C)<<1 +D = deux_octets avec A, B, C, D des
bitsets<4>.to_ulong() )
Non, il n'existe pas de solution toute faite. Mais dans ton
cas (N = 4), c'est particulièrement simple, il suffit de
grouper les bitsets 2 par 2 dans un octet :
std::ostream&
operator<<(std::ostream& dest,
std::vector< std::bitset<4> > const& source)
{
int i;
for(i = 0; i < source.size() - 1; i += 2)
{
dest.put(source[i].to_ulong() + (source[i + 1].to_ulong() <<
4));
}
if (i < source.size())
{
dest.put(source[i].to_ulong());
}
return dest;
}
Je vais reformuler un peu ce qui me tracasse. Pour placer un
vector<bitset> dans un 'truc' (flux, char*, int), suis-je
obligé de convertir un après l'autre tous les bitsets de mon
vecteur ? N'existe-t-il pas une façon toute faite de le
transformer en suite de 0 et de 1 ? ou de transformer
plusieurs bitsets d'un coup ? (plus efficace que ((A<<1 +
B)<<1 + C)<<1 +D = deux_octets avec A, B, C, D des
bitsets<4>.to_ulong() )
Non, il n'existe pas de solution toute faite. Mais dans ton
cas (N = 4), c'est particulièrement simple, il suffit de
grouper les bitsets 2 par 2 dans un octet :
std::ostream&
operator<<(std::ostream& dest,
std::vector< std::bitset<4> > const& source)
{
int i;
for(i = 0; i < source.size() - 1; i += 2)
{
dest.put(source[i].to_ulong() + (source[i + 1].to_ulong() <<
4));
}
if (i < source.size())
{
dest.put(source[i].to_ulong());
}
return dest;
}