Storing objects of an hierarchy in a vector

[sarmadys]

Hello,

I have a hierarchy of Actions (NonMovingActions and MovinActions each with sub-hierarchies). Actions class has an abstract function.

class Action
{
public:
	Action(Agent& agent, ...):agent(agent),..{}
	virtual ~Action(void);

	virtual bool run()=0;
        ...
}

Now I need to store all actions into a single vector:

class Agent
{
public:
    Agent(World& world);
    virtual ~Agent(void);
    ...
   vector<Action> actions;
   unsigned int actionIterator;

}

It appears that C++ does not allow this (in Java it was possible). Compiler objects that Action class is abstract (and cannot be instantiated?!)

error C2259: 'Action' : cannot instantiate abstract class

1- May I know what do I not understand here? We cannot refer to sub-class instances with a reference of parent class type?

2- Should I use vector of pointers instead or what?

I appreciate your time and help.

Regards,
Mac

[laserlight]

It appears that C++ does not allow this (in Java it was possible).

It is not possible in Java either since Java only has reference variables for objects.

1- May I know what do I not understand here? We cannot refer to sub-class instances with a reference of parent class type?

You can. However, Action is not a reference (or pointer). A vector<Action> is a vector of objects where each object is of the Action class, and not of any Action subclass. Since Action is an abstract base class, you thus cannot have a vector<Action> since objects of the Action class itself cannot exist.

2- Should I use vector of pointers instead or what?

Yes, or a vector of smart pointers, or a boost::ptr_vector<Action>.

[sarmadys]

Thank you very much for your help and time.

It is not possible in Java either since Java only has reference variables for objects.

I used to have an ArrayList<Action> and just add all sub-class instances into it and it would not object.

Yes, or a vector of smart pointers, or a boost::ptr_vector<Action>.

So by using pointers now I should use "new" and manage the dellocation myself using "delete". right? It is going to be more messy. That's why I try to use C++ automatic "garbage collection LIKE" mechanism.

Thank you again.

[laserlight]

I used to have an ArrayList<Action> and just add all sub-class instances into it and it would not object.

You are mistaken: you did not "add all sub-class instances into it". You added references to those instances to the ArrayList. In colloquial terminology we say "instance" in Java to also mean a reference to that instance, but technically you are storing references to the instances, not the instances themselves.

So by using pointers now I should use "new" and manage the dellocation myself using "delete". right?

Yes, unless you are just storing pointers that point to existing objects.

It is going to be more messy. That's why I try to use C++ automatic "garbage collection LIKE" mechanism.

Use vector of smart pointers or a boost::ptr_vector<Action>.

[sarmadys]

Use vector of smart pointers or a boost::ptr_vector<Action>.

I am sorry to take more time of you. Boost documentation for ptr_vector does not describe what is exactly the benefit of using it instead of std::vector. May I know that?

[laserlight]

Boost documentation for ptr_vector does not describe what is exactly the benefit of using it instead of std::vector. May I know that?

It is stated in the general documentation for Boost pointer containers.

[monarch_dodra]

Alternatively, You could create an ActionHolder class, which stores a pointer to an Action.

Also known as the opaque pointer design pattern.