Kai-Uwe Bux wrote:
cm****@hotmail. com wrote:
>Hi All
Is there any alternative way to let parent class hold a vector of
its child class's objects?
I meant when i create an object from the child class, in the parent
class, i am able to reference that object.
#include <string>
#include <vector>
#include <iostream>
using namespace std;
class mother{
private:
protected:
vector <void *>list;
mother(){
}
public:
static mother * getInstance(){
static mother m;
return &m;
}
vector <void ** getList(){
return &list;
}
};
class child : mother{
public:
child(){
cout<<"child()" <<endl;
mother::getIns tance()->getList()->push_back((voi d *)this);
cout<<"list->size()="<<(int )mother::getIns tance()->getList()->size()<<endl ;
> }
};
void dumpVector(vect or <void **v){
for (int x=0;x<v->size();x++){
What is the purpose of the following two lines?
> vector <void *>vv=*v;
int yy=(int)vv[x];
cout<<(*v)[x]<<endl;
}
}
int main(){
dumpVector(moth er::getInstance ()->getList());
child *c=new child();
dumpVector(moth er::getInstance ()->getList());
return 0;
}
What is the problem that you are trying to solve?
Anyway, here is an idea without void* and without casting:
#include <vector>
#include <string>
#include <iostream>
class mother {
typedef mother* pointer;
typedef std::vector< pointer instance_list;
static
instance_list &
get_instances ( void ) {
static instance_list instances;
return ( instances );
}
public:
mother ( void ) {
get_instances() .push_back( this );
}
virtual
std::string get_name ( void ) const {
return ( "mother" );
}
static
void dump ( std::ostream& o_str ) {
for ( instance_list:: const_iterator iter = get_instances() .begin();
iter != get_instances() .end(); ++iter ) {
o_str << (*iter)->get_name() << '\n';
}
}
virtual
~mother ( void ) {}
};
[test code snipped]
Ok, I reconsidered. The above has some very visible shortcomings. In
particular, it only adds to the list but it never removes pointers from the
list when the pointees are destructed -- very bad. Also, I forgot about
copy constructors, ...
Here is another approach packaging the solution into a policy template from
which you derive:
#include <set>
template < typename T >
struct tracked {
typedef T * pointer;
typedef T & reference;
private:
typedef tracked * base_pointer;
typedef std::set< base_pointer set_type;
public:
typedef typename set_type::size_ type size_type;
struct obj_iterator : public set_type::const _iterator {
obj_iterator ( typename set_type::const _iterator it )
: set_type::const _iterator( it )
{}
reference operator* ( void ) const {
return ( * up_cast( set_type::const _iterator::oper ator*() ) );
}
pointer operator-( void ) const {
return ( up_cast( set_type::const _iterator::oper ator*() ) );
}
};
static
bool has_objects ( void ) {
return( ! the_set().empty () );
}
static
bool is_valid ( pointer * ptr ) {
return ( the_set().find( ptr ) != the_set().end() );
}
static
size_type num_objects ( void ) {
return ( the_set().size( ) );
}
static
obj_iterator obj_begin ( void ) {
return ( the_set().begin () );
}
static
obj_iterator obj_end ( void ) {
return ( the_set().end() );
}
protected:
tracked ( void ) {
the_set().inser t( this );
}
tracked ( tracked const & ) {
the_set().inser t( this );
}
~tracked ( void ) {
the_set().erase ( this );
}
static
void create_set ( void ) {
the_set();
}
private:
static
pointer up_cast ( base_pointer bp ) {
return ( static_cast< pointer >( bp ) );
}
static
set_type & the_set ( void ) {
static set_type dummy;
return ( dummy );
}
}; // tracked
#include <iostream>
struct mother : public tracked< mother {
virtual
std::string get_name ( void ) const {
return ( "mother" );
}
virtual
~mother ( void ) {
std::cout << "destroying " << get_name() << ".\n";
}
};
class child_a : public mother {
public:
child_a ( void ) : mother() {}
std::string get_name ( void ) const {
return ( "child_a" );
}
virtual
~child_a ( void ) {
std::cout << "destroying " << get_name() << ", ";
}
};
class child_b : public mother {
public:
child_b ( void ) : mother() {}
std::string get_name ( void ) const {
return ( "child_b" );
}
virtual
~child_b ( void ) {
std::cout << "destroying " << get_name() << ", ";
}
};
int main ( void ) {
new mother;
new child_a;
new mother;
new child_b;
new child_a;
for ( mother::obj_ite rator iter = mother::obj_beg in();
iter != mother::obj_end (); ++iter ) {
std::cout << iter->get_name() << '\n';
}
while ( mother::has_obj ects() ) {
delete ( mother::obj_beg in().operator->() );
}
}
Best
Kai-Uwe Bux
