j'ai une classe X avec une donnée membre de type std::map.
Dans cette map, les clés sont des vector (à peu de chose près) et les
données des pointeurs vers une classe de base d'objets, alloués par new.
Pour simplifier ma prose,
typedef std::map<....> type_map;
type_map data_; // donnée membre
Ma question :
Dans le constructeur de copie de la classe X, comment faire pour
"recopier" la map ?
Choix 1)
X(X const& x)
{
for(type_map::const_iterator it=x.data_.begin();it!=x.data_.end();++it)
data_.insert( /* blablabla */ );
}
ou
Choix 2)
X(X const& x)
{
data_=x.data_;
for(type_map::iterator it1Úta_.begin(),
type_map::const_iterator it2=x.data_.begin();
it1!Úta_.end();
++it1,++it2)
it1->second=it2->second()->duplicate();
}
j'ai une classe X avec une donnée membre de type std::map.
Dans cette map, les clés sont des vector (à peu de chose près) et les
données des pointeurs vers une classe de base d'objets, alloués par new.
Pour simplifier ma prose,
typedef std::map<....> type_map;
type_map data_; // donnée membre
Ma question :
Dans le constructeur de copie de la classe X, comment faire pour
"recopier" la map ?
Choix 1)
X(X const& x)
{
for(type_map::const_iterator it=x.data_.begin();it!=x.data_.end();++it)
data_.insert( /* blablabla */ );
}
ou
Choix 2)
X(X const& x)
{
data_=x.data_;
for(type_map::iterator it1Úta_.begin(),
type_map::const_iterator it2=x.data_.begin();
it1!Úta_.end();
++it1,++it2)
it1->second=it2->second()->duplicate();
}
j'ai une classe X avec une donnée membre de type std::map.
Dans cette map, les clés sont des vector (à peu de chose près) et les
données des pointeurs vers une classe de base d'objets, alloués par new.
Pour simplifier ma prose,
typedef std::map<....> type_map;
type_map data_; // donnée membre
Ma question :
Dans le constructeur de copie de la classe X, comment faire pour
"recopier" la map ?
Choix 1)
X(X const& x)
{
for(type_map::const_iterator it=x.data_.begin();it!=x.data_.end();++it)
data_.insert( /* blablabla */ );
}
ou
Choix 2)
X(X const& x)
{
data_=x.data_;
for(type_map::iterator it1Úta_.begin(),
type_map::const_iterator it2=x.data_.begin();
it1!Úta_.end();
++it1,++it2)
it1->second=it2->second()->duplicate();
}
Si les performances sont importantes, pourquoi pas, mais plus simple :
X(X const& x)
: data(x.data)
{
for(type_map::iterator it = data.begin(); it != data.end(); ++it)
it->second = it->second->duplicate();
}
Attention quand même au comportement en cas d'exception.
Si les performances sont importantes, pourquoi pas, mais plus simple :
X(X const& x)
: data(x.data)
{
for(type_map::iterator it = data.begin(); it != data.end(); ++it)
it->second = it->second->duplicate();
}
Attention quand même au comportement en cas d'exception.
Si les performances sont importantes, pourquoi pas, mais plus simple :
X(X const& x)
: data(x.data)
{
for(type_map::iterator it = data.begin(); it != data.end(); ++it)
it->second = it->second->duplicate();
}
Attention quand même au comportement en cas d'exception.
j'ai une classe X avec une donnée membre de type std::map.
Dans cette map, les clés sont des vector (à peu de chose près) et l es
données des pointeurs vers une classe de base d'objets, alloués par n ew.
Pour simplifier ma prose,
typedef std::map<....> type_map;
type_map data_; // donnée membre
Ma question :
Dans le constructeur de copie de la classe X, comment faire pour "recopie r"
la map ?
Choix 1)
X(X const& x)
{
for(type_map::const_iterator it=x.data_.begin();it!=x.data_.end() ;++it)
data_.insert( /* blablabla */ );
}
ou
Choix 2)
X(X const& x)
{
data_=x.data_;
for(type_map::iterator it1Úta_.begin(),
type_map::const_iterator it2=x.data_.begin();
it1!Úta_.end();
++it1,++it2)
it1->second=it2->second()->duplicate();
}
je pense que le choix 2 est préférable...mais je voudrais
avoir votre avis.
Je ne sais pas comment est implémentée la copie des map dans
la STL, mais je pense qu'elle doit tenir compte du fait que
les clés sont déjà triées !
j'ai une classe X avec une donnée membre de type std::map.
Dans cette map, les clés sont des vector (à peu de chose près) et l es
données des pointeurs vers une classe de base d'objets, alloués par n ew.
Pour simplifier ma prose,
typedef std::map<....> type_map;
type_map data_; // donnée membre
Ma question :
Dans le constructeur de copie de la classe X, comment faire pour "recopie r"
la map ?
Choix 1)
X(X const& x)
{
for(type_map::const_iterator it=x.data_.begin();it!=x.data_.end() ;++it)
data_.insert( /* blablabla */ );
}
ou
Choix 2)
X(X const& x)
{
data_=x.data_;
for(type_map::iterator it1=data_.begin(),
type_map::const_iterator it2=x.data_.begin();
it1!=data_.end();
++it1,++it2)
it1->second=it2->second()->duplicate();
}
je pense que le choix 2 est préférable...mais je voudrais
avoir votre avis.
Je ne sais pas comment est implémentée la copie des map dans
la STL, mais je pense qu'elle doit tenir compte du fait que
les clés sont déjà triées !
j'ai une classe X avec une donnée membre de type std::map.
Dans cette map, les clés sont des vector (à peu de chose près) et l es
données des pointeurs vers une classe de base d'objets, alloués par n ew.
Pour simplifier ma prose,
typedef std::map<....> type_map;
type_map data_; // donnée membre
Ma question :
Dans le constructeur de copie de la classe X, comment faire pour "recopie r"
la map ?
Choix 1)
X(X const& x)
{
for(type_map::const_iterator it=x.data_.begin();it!=x.data_.end() ;++it)
data_.insert( /* blablabla */ );
}
ou
Choix 2)
X(X const& x)
{
data_=x.data_;
for(type_map::iterator it1Úta_.begin(),
type_map::const_iterator it2=x.data_.begin();
it1!Úta_.end();
++it1,++it2)
it1->second=it2->second()->duplicate();
}
je pense que le choix 2 est préférable...mais je voudrais
avoir votre avis.
Je ne sais pas comment est implémentée la copie des map dans
la STL, mais je pense qu'elle doit tenir compte du fait que
les clés sont déjà triées !
j'ai une classe X avec une donnée membre de type std::map.
Dans cette map, les clés sont des vector (à peu de chose près) et les
données des pointeurs vers une classe de base d'objets, alloués par new.
Des clés, et non des valeurs ? Parce que des clés, dans un map,
doivent être immutable.
j'ai une classe X avec une donnée membre de type std::map.
Dans cette map, les clés sont des vector (à peu de chose près) et les
données des pointeurs vers une classe de base d'objets, alloués par new.
Des clés, et non des valeurs ? Parce que des clés, dans un map,
doivent être immutable.
j'ai une classe X avec une donnée membre de type std::map.
Dans cette map, les clés sont des vector (à peu de chose près) et les
données des pointeurs vers une classe de base d'objets, alloués par new.
Des clés, et non des valeurs ? Parce que des clés, dans un map,
doivent être immutable.
La première question que je me poserais, ici, c'est s'il faut
supporter la copie, parce qu'elle va être chère. (Mais je
suppose que tu t'es déjà posé cette question-là.)
Si c'est les clés que tu veux copier, c'est it->first. Et cette
solution ne marche pas, parce que le type d'it->first est const.
J'avoue que pour l'instant, je ne vois pas comment ils
fonctionnent réelement, ni l'un ni l'autre.
La première question que je me poserais, ici, c'est s'il faut
supporter la copie, parce qu'elle va être chère. (Mais je
suppose que tu t'es déjà posé cette question-là.)
Si c'est les clés que tu veux copier, c'est it->first. Et cette
solution ne marche pas, parce que le type d'it->first est const.
J'avoue que pour l'instant, je ne vois pas comment ils
fonctionnent réelement, ni l'un ni l'autre.
La première question que je me poserais, ici, c'est s'il faut
supporter la copie, parce qu'elle va être chère. (Mais je
suppose que tu t'es déjà posé cette question-là.)
Si c'est les clés que tu veux copier, c'est it->first. Et cette
solution ne marche pas, parce que le type d'it->first est const.
J'avoue que pour l'instant, je ne vois pas comment ils
fonctionnent réelement, ni l'un ni l'autre.
"James Kanze" a écrit dans le message de news:
On Oct 17, 5:10 pm, "Marc G" wrote:j'ai une classe X avec une donnée membre de type std::map.
Dans cette map, les clés sont des vector (à peu de chose près) e t les
données des pointeurs vers une classe de base d'objets, alloués pa r new.
Des clés, et non des valeurs ? Parce que des clés, dans un map,
doivent être immutable.
J'ai compris que le pointeur était la donnée et non la clé (la
clé étant "un vector à peu de chose pret").
"James Kanze" <james.ka...@gmail.com> a écrit dans le message de news:
1192697305.623721.95...@q5g2000prf.googlegroups.com...
On Oct 17, 5:10 pm, "Marc G" <mgueg...@metrica.fr> wrote:
j'ai une classe X avec une donnée membre de type std::map.
Dans cette map, les clés sont des vector (à peu de chose près) e t les
données des pointeurs vers une classe de base d'objets, alloués pa r new.
Des clés, et non des valeurs ? Parce que des clés, dans un map,
doivent être immutable.
J'ai compris que le pointeur était la donnée et non la clé (la
clé étant "un vector à peu de chose pret").
"James Kanze" a écrit dans le message de news:
On Oct 17, 5:10 pm, "Marc G" wrote:j'ai une classe X avec une donnée membre de type std::map.
Dans cette map, les clés sont des vector (à peu de chose près) e t les
données des pointeurs vers une classe de base d'objets, alloués pa r new.
Des clés, et non des valeurs ? Parce que des clés, dans un map,
doivent être immutable.
J'ai compris que le pointeur était la donnée et non la clé (la
clé étant "un vector à peu de chose pret").
La première question que je me poserais, ici, c'est s'il faut
supporter la copie, parce qu'elle va être chère. (Mais je
suppose que tu t'es déjà posé cette question-là.)
oui, il le faut, même si elle sera peu utiliséeSi c'est les clés que tu veux copier, c'est it->first. Et cette
solution ne marche pas, parce que le type d'it->first est const.
J'avoue que pour l'instant, je ne vois pas comment ils
fonctionnent réelement, ni l'un ni l'autre.
je te remercie pour l'effort que tu as fait à me répondre...
Malheureusement, je crois ne pas avoir été assez clair dans ma
formulation...
Voilà plus précisement comment se présente l'ensemble :
class keys {
//......
std::vector<std::string> keys_;
};
class CObject; // c'est une classe de base d'une hiérarchie avec foncti ons
virtuelles
class X {
public :
typedef std::map< keys ,CObject*, std::less<keys> > da ta;
// constructeur de copie
explicit X(Xconst& source)
: data_(source.data_) //<==== ma question était là...
{
for(data_iterator itÚta_.begin();it!Úta_.end();++it)
it->second=it->second->duplicate();
}
~X()
{
for(data_const_iterator itÚta_.begin();it!Úta_.end();++it)
if (it->second) delete it->second;
data_.clear();
}
data data_;
};
je recopie le pointeur avec et ensuite je l'écrase en
récupérant l'adresse de l'objet dupliqué par duplicate().
duplicate() n'a aucun risque de lever une exception...sauf en
cas de mémoire insuffisante.
Si une exception liée à la mémoire est levée, le destructeur
est-il appelé ?
duplicate()) ) ;
}
Dans ce cas, j'ai plutôt intérêt à écrire
// constructeur de copie
explicit X(Xconst& source)
: data_(source.data_)
{
data_iterator it1Úta_.begin();
data_const_iterator it2=source.data_.begin();
for(;it1!Úta_.end();++it1)
it1->second=NULL;
it1Úta_.begin();
for(;it1!Úta_.end();++it1,++it2)
it1->second=it2->second->duplicate();
}
Qu'en penses-tu ?
La première question que je me poserais, ici, c'est s'il faut
supporter la copie, parce qu'elle va être chère. (Mais je
suppose que tu t'es déjà posé cette question-là.)
oui, il le faut, même si elle sera peu utilisée
Si c'est les clés que tu veux copier, c'est it->first. Et cette
solution ne marche pas, parce que le type d'it->first est const.
J'avoue que pour l'instant, je ne vois pas comment ils
fonctionnent réelement, ni l'un ni l'autre.
je te remercie pour l'effort que tu as fait à me répondre...
Malheureusement, je crois ne pas avoir été assez clair dans ma
formulation...
Voilà plus précisement comment se présente l'ensemble :
class keys {
//......
std::vector<std::string> keys_;
};
class CObject; // c'est une classe de base d'une hiérarchie avec foncti ons
virtuelles
class X {
public :
typedef std::map< keys ,CObject*, std::less<keys> > da ta;
// constructeur de copie
explicit X(Xconst& source)
: data_(source.data_) //<==== ma question était là...
{
for(data_iterator it=data_.begin();it!=data_.end();++it)
it->second=it->second->duplicate();
}
~X()
{
for(data_const_iterator it=data_.begin();it!=data_.end();++it)
if (it->second) delete it->second;
data_.clear();
}
data data_;
};
je recopie le pointeur avec et ensuite je l'écrase en
récupérant l'adresse de l'objet dupliqué par duplicate().
duplicate() n'a aucun risque de lever une exception...sauf en
cas de mémoire insuffisante.
Si une exception liée à la mémoire est levée, le destructeur
est-il appelé ?
duplicate()) ) ;
}
Dans ce cas, j'ai plutôt intérêt à écrire
// constructeur de copie
explicit X(Xconst& source)
: data_(source.data_)
{
data_iterator it1=data_.begin();
data_const_iterator it2=source.data_.begin();
for(;it1!=data_.end();++it1)
it1->second=NULL;
it1=data_.begin();
for(;it1!=data_.end();++it1,++it2)
it1->second=it2->second->duplicate();
}
Qu'en penses-tu ?
La première question que je me poserais, ici, c'est s'il faut
supporter la copie, parce qu'elle va être chère. (Mais je
suppose que tu t'es déjà posé cette question-là.)
oui, il le faut, même si elle sera peu utiliséeSi c'est les clés que tu veux copier, c'est it->first. Et cette
solution ne marche pas, parce que le type d'it->first est const.
J'avoue que pour l'instant, je ne vois pas comment ils
fonctionnent réelement, ni l'un ni l'autre.
je te remercie pour l'effort que tu as fait à me répondre...
Malheureusement, je crois ne pas avoir été assez clair dans ma
formulation...
Voilà plus précisement comment se présente l'ensemble :
class keys {
//......
std::vector<std::string> keys_;
};
class CObject; // c'est une classe de base d'une hiérarchie avec foncti ons
virtuelles
class X {
public :
typedef std::map< keys ,CObject*, std::less<keys> > da ta;
// constructeur de copie
explicit X(Xconst& source)
: data_(source.data_) //<==== ma question était là...
{
for(data_iterator itÚta_.begin();it!Úta_.end();++it)
it->second=it->second->duplicate();
}
~X()
{
for(data_const_iterator itÚta_.begin();it!Úta_.end();++it)
if (it->second) delete it->second;
data_.clear();
}
data data_;
};
je recopie le pointeur avec et ensuite je l'écrase en
récupérant l'adresse de l'objet dupliqué par duplicate().
duplicate() n'a aucun risque de lever une exception...sauf en
cas de mémoire insuffisante.
Si une exception liée à la mémoire est levée, le destructeur
est-il appelé ?
duplicate()) ) ;
}
Dans ce cas, j'ai plutôt intérêt à écrire
// constructeur de copie
explicit X(Xconst& source)
: data_(source.data_)
{
data_iterator it1Úta_.begin();
data_const_iterator it2=source.data_.begin();
for(;it1!Úta_.end();++it1)
it1->second=NULL;
it1Úta_.begin();
for(;it1!Úta_.end();++it1,++it2)
it1->second=it2->second->duplicate();
}
Qu'en penses-tu ?