[ACCEPTED]-In C++, how can I hold a list of an abstract class?-abstract
You cannot instantiate the object because 5 it is abstract as you said. You can however 4 hold a vector of pointers to the DCMessage 3 class which will work, you just need to 2 add the memory address and not the object 1 when pushing it on to the list.
vector<DCMessage*> queue; DCCmd* commandObject = new DCCmd(...params...); queue.push_back(commandObject); BYTE* params = queue->getParams();
You want a vector of DCMessage pointers:
vector<DCMessage*> messages; messages.push_back(new DCCmd(blah));
Polymorphism 3 in C++ only works through pointers and references, and 2 you can't use references for this. So, pointers 1 it is.
If you want polymorphism, you need pointers 16 in C++, so would use a deque of pointers 15 to the abstract type ( assuming it's a FIFO 14 queue rather than a LIFO ). You then have 13 the problem of managing who owns the messages 12 in the queue.
However, C++ isn't just about 11 OO, and there are idioms in C++ for writing 10 objects to streams; if the message queue 9 just forwards them to a tcp port or has 8 a behaviour similar to , you might want 7 to use those idioms and copy the data rather 6 than storing a reference to the object. If 5 you're implementing techniques to marshall 4 your message objects to and from binary 3 anyway, you might end up saving yourself 2 some bother if your queue is just a buffered 1 stream.
(Voted Kelix up, but I think this needs 12 more elaboration)
What you are looking to 11 do is create a vector of elements that can 10 be of any object derived from your abstract 9 class, right? When you say
vector <DCMessage>, you are instead 8 asking for a vector of elements of class 7 DCMessage. You can't have them, as that 6 is an abstract class.
If you instead ask 5 for
vector <DCMessage *>, then you can supply pointers to objects 4 of any class derived from DCMessage, and 3 will get dynamic (runtime) dispatch to the 2 correct implementation of your abstract 1 routines when invoked at runtime.
Other answers point out that you can have 9 only pointers of abstract classes. When 8 you use that in a container like list, after 7 you remove elements, you will have to manually 6 remove their memory as well, since the container 5 operations will just work on the pointer 4 value itself and not what is being pointed 3 to.
In cpp-11 you can use wrappers like
unique_ptr<some_type> to 2 achieve your goal without dealing directly 1 with pointers:
list<unique_ptr<your_abstract_class>> someList; someList.push_back(make_unique<your_derived_class>()); // will create new instance someList.push_back(make_unique<your_other_derived_class>()); someList.pop_front(); // will remove the instance and automatically call its destructor
More Related questions