Re: copying a vector of objects at runtime
"Julian" <julvar@nospamtamu.edu> wrote in
news:g54akk$c32$1@news.tamu.edu:
Hi,
I have a vector defined like this:
std::vector<Load*> LoadList;
which is populated with different objects of classes that are derived
from 'Load'.
I need to make a copy of this list during runtime.
I imagine I'd have to loop through the list, make a copy of each of
the objects in the vector using the copy constructor... but I don't
know the class name during run time so that I can call the appropriate
copy constructor.
Hmmm, if copying the objects in the vector is the answer, then I have to
wonder why there are pointers in the vector to begin with. That is,
wouldn't vector<Load> have been a better place to start? Then copying
would be as simple as LoadList2 = LoadList. IME the only time you
really want a vector of pointers is if the objects have identity
(can't/shouldn't be copied at all) or are horrendously expensive to
copy.
If you still want to copy the vector of pointers (after considering
making them value types instead), you can do something like:
#include <iostream>
#include <sstream>
#include <vector>
template <typename T>
T * clone(T * a)
{
return new T(*a); //assuming copy constructor
}
template <typename T>
class clone_insert_iterator : public std::iterator
<std::output_iterator_tag, typename T::value_type>
{
T& m_Container;
public:
explicit clone_insert_iterator(T & container) : m_Container
(container) {}
clone_insert_iterator<T> & operator=(typename T::value_type const &
a)
{
m_Container.push_back(clone(a));
return *this;
}
clone_insert_iterator<T> & operator*()
{
return *this;
}
clone_insert_iterator<T> & operator++()
{
return *this;
}
clone_insert_iterator<T> operator++(int)
{
return *this;
}
};
int main()
{
std::vector<int *> v;
std::vector<int *> v1;
v.push_back(new int(5));
v.push_back(new int(1));
v.push_back(new int(10));
v.push_back(new int(7));
clone_insert_iterator<std::vector<int *> > cii(v1);
std::copy(v.begin(), v.end(), cii);
for (int ix = 0; ix < v1.size(); ++ix)
{
std::cout << *v[ix] << std::endl;
}
std::cout << std::endl;
std::cout << std::endl;
for (int ix = 0; ix < v1.size(); ++ix)
{
std::cout << *v1[ix] << std::endl;
}
}
Which seems to work, but I made no attempt at robustness nor
completeness for any particular use.
joe