Wrap different std::vector in same interface

Question

I have 2 classes for managing 2 queues of different types (something in the form of list<myType1*> and list<myType1*>). To simplify the case, we can use here std::vector<std::string> and std::vector<int> as in the example below:

class StringQueue
{

public:
    StringQueue();
    ~StringQueue();

    int count() const {return m_queue.size();}
    void add(std::string item) {m_queue.push_back(item);}
    void clear() {m_queue.clear();}
    ...etc...

protected:
    std::vector<std::string> m_queue;
};

class IntQueue
{

public:
    IntQueue();
    ~IntQueue();

    int count() const {return m_queue.size();}
    void add(int item) {m_queue.push_back(item);}
    void clear() {m_queue.clear();}
    ...etc...

protected:
    std::vector<int> m_queue;
};

For every Queue class, I have many functions to access the queue (add, clear, count, check, pop one, pop multiple, etc...)

Looking at the code, my question now is: is it possible to use inheritance here? I know I can implement a Queue base class, but only a couple of functions can be derived (count() in the example above) since the m_queue object is different, even if the functions (add, clear, etc...) are the same. Is it possible to have a complete functions inheritance even if the std::vector elements are different?

I'm thinking something like:

class Queue
{

public:
    Queue();
    ~Queue();

    int count() const {return m_queue.size();}
    void add(T item) {m_queue.push_back(item);}
    void clear() {m_queue.clear();}
    ...etc...

protected:
    std::vector<T> m_queue;
};

Is there a way to achieve this?

Inheriting standard container classes is a very bad idea. Use them as member variables instead. — πάντα ῥεῖ, Sep 03 '19 at 10:50
As it seems the OP is interested in templatizing the class. It seems the title is just wrong/misleading. — moooeeeep, Sep 03 '19 at 10:52
@πάνταῥεῖ No concern. Your comment could be interpreted as an answer to the question before... — Benjamin Bihler, Sep 03 '19 at 10:55
Should rather be closed as a duplicate to this, imo: https://stackoverflow.com/q/3251549/1025391 — moooeeeep, Sep 03 '19 at 10:59
@moooeeeep Yes, a template version might help in reducing to write boiler plate stuff. — πάντα ῥεῖ, Sep 03 '19 at 10:59
I think the question is not a duplicate. I don't want to inherit from containers. I would like to use containers for managing 2 queues of different types. I don't need the standard container methods interface — ABCplus, Sep 03 '19 at 11:00
I'm wondering why you don't use template version of the class!! is there any good reason for avoiding that? — Saeed Masoomi, Sep 03 '19 at 11:02
Have a look at any std::stack or std::priority_queue implementation. It's a container wrapper like the one you want. Also, NEVER inherit from any STL container. — One Man Monkey Squad, Sep 03 '19 at 11:02
If you don't want to inherit from containers, what did you expect people to understand by "Inherit from a std::vector"? — Useless, Sep 03 '19 at 11:12
Never inherit from `std::vector`. Its destructor is not virtual — Aykhan Hagverdili, Sep 03 '19 at 11:40
@Useless you're right. Title edited by somebody more expert than me — ABCplus, Sep 03 '19 at 11:48
@Ayxan Polymorphism is not the only purpose of inheritance. It's perfectly fine to inherit from a non-virtual base, just you then cannot use such a class polymorphically. — Daniel Langr, Sep 03 '19 at 12:19

score 2 · Accepted Answer · answered Sep 03 '19 at 12:14

This is a perfect job for templates:

template<class T>
class MyQueue
{
public:
    MyQueue();
    ~MyQueue();

    int count() const {return m_queue.size();}
    void add(T item) {m_queue.push_back(item);}
    void clear() {m_queue.clear();}
    T popOne()
    {
      T front = m_queue.front();
      m_queue.erase(m_queue.begin());
      return front;
    }
    ...etc...

protected:
    std::vector<T> m_queue;
};

Inheritance is not the right tool for the job, for the reasons you identified yourself.

However:

Why don't you use std::queue and friends, which already do exactly this wrapping?
Why do you want to build a queue based on std::vector - erasing elements from the front involves moving every other element one slot forward. That's about as expensive as it gets...

I recommend you read up more on templates if you want to use them further. While the above code looks nice and easy, writing templated code in C++ has its own set of challenges.

Wrap different std::vector in same interface

1 Answers1