std :: queue具有不同的容器类型，具体取决于运行时数据

Question

I have a class which needs to use a std::queue as an instance var to store some data. My problem is that std::queue either uses std::deque as container type by default or one needs to provide another container type at compile time. But which container I would like to use depends on some runtime data of the class user, therefore I can't specify it on compile time. After instanciation of the std::queue and providing the proper container implementation I don't care anymore about the container itself, but only use the interface of std::queue.

The containers I would like to provide are std::deque or boost::circular_buffer and both store the same type of elements, it's only that one is used whenever the caller would like to store infinite amount of data and the circular _buffer if not.

The only way I found so far is a custom abstract base class acting as common interface with two derived implementations for the different std::queue instances. But in that case I have to duplicate the interface of std::queue which is really annoying.

Is there any way to declare and instanciate a std::queue in such a way? Something like "std::queue with unknown/runtime provided container".

Answer 1

Template parameters must be known at compile type. You would not be able to change the underlying container of the queue at run time. What you could do is some sort of wrapper or union that combines the two types of queues together and then use one or the other at run time depending on the run time condition.

Answer 2

If you do not expect to have a lot of instances of that class, then a very low-tech, simple, but ultimately working approach would be to simply add two different member variables to your class: a std::queue<T> and a std::queue<T, boost::circular_buffer<T>> . Then choose the appropriate container at run-time, when you instantiate the class.

This will cost you a few additional bytes per instance of your class, becaus there will be one unused empty container in each, but at the same time spare you from any difficulties or over-complicated code you might experience with unions, boost::variant , void* or similar things.

Here is a complete example:

#include <boost/circular_buffer.hpp>
#include <queue>
#include <deque>
#include <iostream>

class YourClass
{
public:
    YourClass(bool needs_infinite_amount_of_data) :
        needs_infinite_amount_of_data(needs_infinite_amount_of_data),
        queue(),
        queue_with_circular_buffer(boost::circular_buffer<int>(needs_infinite_amount_of_data ? 0 : 100))
    {
    }

    void Operation()
    {
        if (needs_infinite_amount_of_data)
        {
            Operation(queue);
        }
        else
        {
            Operation(queue_with_circular_buffer);
        }
    }

private:
    template <class Container>
    static void Operation(Container& container)
    {
        container.push(1);
        std::cout << container.front() << "\n";
    }

    bool needs_infinite_amount_of_data;
    std::queue<int> queue;
    std::queue<int, boost::circular_buffer<int>> queue_with_circular_buffer;
};

int main()
{
    YourClass obj(false);
    obj.Operation();
}