468,256 Members | 1,417 Online
Bytes | Developer Community
New Post

Home Posts Topics Members FAQ

Post your question to a community of 468,256 developers. It's quick & easy.

How to copy a vector if pointers to base class

hello

I'm trying to implement a copy constructor for a vector of pointers to
a base class (which is abstract)

My question is how would i know what kind of new type should i
allocate since the base poiner can have multipull meanings.

i know i can use dynamic_cast however i really don't like this
solution and i was wondering is i can do something better

thanks
Jun 27 '08 #1
10 2039
Alex Snast wrote:
hello

I'm trying to implement a copy constructor for a vector of pointers to
a base class (which is abstract)

My question is how would i know what kind of new type should i
allocate since the base poiner can have multipull meanings.

i know i can use dynamic_cast however i really don't like this
solution and i was wondering is i can do something better
The standard trick is to provide a virtual clone() member in the base class.
You can then copy the vector by using std::transform with a back_inserter
and a functor like this

Base* deep_copy ( Base * ptr ) {
return( ptr->clone() );
}

or some of these unreadable pointer to member function binders.

You can also google the archives for copy_ptr or clone_ptr to find smart
pointers with deep copy semantics. Those are non-standard and might make
your code harder to maintain for others since they might not be familiar
with those libraries. On the plus side, you don't need to do anything to
copy a vector of those since the copy constructor of the smart pointer will
to the job.
Best

Kai-Uwe Bux
Jun 27 '08 #2


Kai-Uwe Bux כתב:
Alex Snast wrote:
hello

I'm trying to implement a copy constructor for a vector of pointers to
a base class (which is abstract)

My question is how would i know what kind of new type should i
allocate since the base poiner can have multipull meanings.

i know i can use dynamic_cast however i really don't like this
solution and i was wondering is i can do something better

The standard trick is to provide a virtual clone() member in the base class.
You can then copy the vector by using std::transform with a back_inserter
and a functor like this

Base* deep_copy ( Base * ptr ) {
return( ptr->clone() );
}

or some of these unreadable pointer to member function binders.

You can also google the archives for copy_ptr or clone_ptr to find smart
pointers with deep copy semantics. Those are non-standard and might make
your code harder to maintain for others since they might not be familiar
with those libraries. On the plus side, you don't need to do anything to
copy a vector of those since the copy constructor of the smart pointer will
to the job.
Best

Kai-Uwe Bux
Thanks for the help. Worked just find even though i haven't used
std::transform but rather wrote my own method
Storerepository::Storerepository(const Storerepository& rhs)
throw(OutOfMemory)
{
try {
for (const_repertory_iterator cit = rhs.repertory_.begin(); cit !=
rhs.repertory_.end(); ++cit) {
this->repertory_.push_back((*cit)->clone());
}
}
catch(std::bad_alloc){
throw OutOfMemory();
}
}

thanks again'
Jun 27 '08 #3
In article
<84**********************************@25g2000hsx.g ooglegroups.com>,
Alex Snast <as****@gmail.comwrote:
Kai-Uwe Bux Ι
Alex Snast wrote:
hello
I'm trying to implement a copy constructor for a vector of pointers to
a base class (which is abstract)
My question is how would i know what kind of new type should i
allocate since the base poiner can have multipull meanings.
i know i can use dynamic_cast however i really don't like this
solution and i was wondering is i can do something better
The standard trick is to provide a virtual clone() member in the base
class.
You can then copy the vector by using std::transform with a back_inserter
and a functor like this
Base* deep_copy ( Base * ptr ) {
return( ptr->clone() );
ݚ
or some of these unreadable pointer to member function binders.
You can also google the archives for copy_ptr or clone_ptr to find smart
pointers with deep copy semantics. Those are non-standard and might make
your code harder to maintain for others since they might not be familiar
with those libraries. On the plus side, you don't need to do anything to
copy a vector of those since the copy constructor of the smart pointer will
to the job.

Best
Kai-Uwe Bux

Thanks for the help. Worked just find even though i haven't used
std::transform but rather wrote my own method
Storerepository::Storerepository(const Storerepository& rhs) throw(OutOfMemory)
{
try {
for (const_repertory_iterator cit = rhs.repertory_.begin();
cit != rhs.repertory_.end(); ++cit) {
this->repertory_.push_back((*cit)->clone());
}
}
catch(std::bad_alloc){
throw OutOfMemory();
}
}
Just for the record, Kai-Uwe was recommending something like this:

transform(rhs.repertory_.begin(), rhs.repertory_.end(),
back_inserter(repertory_), &deep_copy);

Or:

transform(rhs.repertory_.begin(), rhs.repertory_.end(),
back_inserter(repertory_), mem_fun(&Base::clone));

You can wrap the above to convert a bad_alloc into an OutOfMemory, but I
don't see a reason to bother...
Jun 27 '08 #4
Hi!

Daniel T. schrieb:
Or:

transform(rhs.repertory_.begin(), rhs.repertory_.end(),
back_inserter(repertory_), mem_fun(&Base::clone));
The mem_fun will not do virtual dispatch here! But you can always do it
like the "C++ Conding Standards" say: have a public non-virtual function
which calls the virtual protected function. Then the above would work.

class Base {
public:
Base* clone() const { return doClone(); }
protected:
virtual Base* doClone()=0;
};

Frank
Jun 27 '08 #5
Frank Birbacher <bl************@gmx.netwrote:
Daniel T. schrieb:
Or:

transform(rhs.repertory_.begin(), rhs.repertory_.end(),
back_inserter(repertory_), mem_fun(&Base::clone));

The mem_fun will not do virtual dispatch here!
You are wrong. mem_fun was specifically designed to do virtual dispatch
in these cases...

struct Base
{
virtual Base* clone() = 0;
};

struct Derived1 : Base
{
virtual Base* clone() {
cout << "Derived1::clone() called\n";
return new Derived1;
}
};

int main()
{
vector<Base*old_vec;
vector<Base*new_vec;
old_vec.push_back( new Derived1 );
old_vec.push_back( new Derived1 );
old_vec.push_back( new Derived1 );
transform(old_vec.begin(), old_vec.end(),
back_inserter(new_vec), mem_fun(&Base::clone));
}
Jun 27 '08 #6
On Jun 9, 1:02 pm, Frank Birbacher <bloodymir.c...@gmx.netwrote:
Daniel T. schrieb:
Or:
transform(rhs.repertory_.begin(), rhs.repertory_.end(),
back_inserter(repertory_), mem_fun(&Base::clone));
The mem_fun will not do virtual dispatch here!
The mem_fun has exactly the same semantics of calling the
function directly; if the function is declared virtual in Base,
and you call it correctly with a pointer to the base, then it
will use virtual dispatch.

--
James Kanze (GABI Software) email:ja*********@gmail.com
Conseils en informatique oriente objet/
Beratung in objektorientierter Datenverarbeitung
9 place Smard, 78210 St.-Cyr-l'cole, France, +33 (0)1 30 23 00 34
Jun 27 '08 #7
Hi!

James Kanze schrieb:
>The mem_fun will not do virtual dispatch here!

The mem_fun has exactly the same semantics of calling the
function directly;
This is nothing a boost::bind could do, right? The mem_fun has extra
help from the compiler here, right?
if the function is declared virtual in Base,
and you call it correctly with a pointer to the base, then it
will use virtual dispatch.
So, the following won't do the same?

struct Base {
virtual void foo() {}
};

struct Dev : Base {
void foo() {}
void test();
};

void Dev::test() {
using boost::bind;

this->Base::foo(); //calls Base::foo
this->*(&Base::foo)(); //calls Base::foo ??
mem_fun(&Base::foo)(this); //calls Dev::foo ?? WTF?
bind(&Base::foo, this)(); //calls Base::foo ??
}

I don't get it. How does mem_fun work?

Frank
Jun 27 '08 #8
Frank Birbacher <bl************@gmx.netwrote:
James Kanze schrieb:
The mem_fun will not do virtual dispatch here!
The mem_fun has exactly the same semantics of calling the
function directly;

This is nothing a boost::bind could do, right? The mem_fun has extra
help from the compiler here, right?
if the function is declared virtual in Base,
and you call it correctly with a pointer to the base, then it
will use virtual dispatch.

So, the following won't do the same?

struct Base {
virtual void foo() {}
};

struct Dev : Base {
void foo() {}
void test();
};

void Dev::test() {
using boost::bind;

this->Base::foo(); //calls Base::foo
this->*(&Base::foo)(); //calls Base::foo ??
mem_fun(&Base::foo)(this); //calls Dev::foo ?? WTF?
bind(&Base::foo, this)(); //calls Base::foo ??
}

I don't get it. How does mem_fun work?
Have you checked out the output of your program above?

struct Base {
virtual void foo() { cout << "Base::foo()\n"; }
};

struct Dev : Base {
void foo() { cout << "Dev::foo()\n"; }
void test();
};

void Dev::test() {
using namespace boost;

this->Base::foo();
(this->*&Base::foo)(); // fixed this line so it compiles
mem_fun(&Base::foo)(this);
bind(&Base::foo, this)();
}

int main()
{
Dev d;
d.test();
}

The output I get is:

Base::foo()
Dev::foo()
Dev::foo()
Dev::foo()

IE: in every case except the first, Dev::foo() is called.
Jun 27 '08 #9
On Jun 9, 3:31 pm, Frank Birbacher <bloodymir.c...@gmx.netwrote:
James Kanze schrieb:
The mem_fun will not do virtual dispatch here!
The mem_fun has exactly the same semantics of calling the
function directly;
This is nothing a boost::bind could do, right? The mem_fun has
extra help from the compiler here, right?
No extra help. It uses a pointer to member function.
if the function is declared virtual in Base, and you call it
correctly with a pointer to the base, then it will use
virtual dispatch.
So, the following won't do the same?
struct Base {
virtual void foo() {}
};
struct Dev : Base {
void foo() {}
void test();
};
void Dev::test() {
using boost::bind;
this->Base::foo(); //calls Base::foo
this->*(&Base::foo)(); //calls Base::foo ??
Doesn't compile.
(this->*(&Base::foo))() ;
calls Dev::foo.
mem_fun(&Base::foo)(this); //calls Dev::foo ?? WTF?
Calls Dev::foo.
bind(&Base::foo, this)(); //calls Base::foo ??
Calls Dev::foo.
}
I don't get it. How does mem_fun work?
It uses a pointer to member function.

--
James Kanze (GABI Software) email:ja*********@gmail.com
Conseils en informatique oriente objet/
Beratung in objektorientierter Datenverarbeitung
9 place Smard, 78210 St.-Cyr-l'cole, France, +33 (0)1 30 23 00 34
Jun 27 '08 #10
Hi!

Daniel T. schrieb:
The output I get is:

Base::foo()
Dev::foo()
Dev::foo()
Dev::foo()

IE: in every case except the first, Dev::foo() is called.
o_O I'm sorry, I have a complete misunderstanding of this issue.

Thanks to both of you, Daniel and James, for clearing things up.

Frank
Jun 27 '08 #11

This discussion thread is closed

Replies have been disabled for this discussion.

Similar topics

39 posts views Thread by scooter | last post: by
4 posts views Thread by The Directive | last post: by
9 posts views Thread by Gunnar G | last post: by
3 posts views Thread by Nudge | last post: by
5 posts views Thread by Ernst Murnleitner | last post: by
5 posts views Thread by canned.net | last post: by
6 posts views Thread by Jia | last post: by
6 posts views Thread by Peng Yu | last post: by
reply views Thread by kermitthefrogpy | last post: by
reply views Thread by zattat | last post: by
By using this site, you agree to our Privacy Policy and Terms of Use.