C :多态容器 /迭代器与编译时间概念 /特征

这是您可能想做的最小可编译示例。

请注意，目前，此示例仅支持const begin（）和const end（）。

添加进一步的方法和可变的迭代器是读者的练习

编辑：提供了共享相同策略类的编译时间和运行时多态性队列的工作示例。

#include <iostream>
#include <list>
#include <vector>
#include <memory>
#include <typeinfo>
#include <typeindex>
/// COMPILE TIME Polymorphic queue of objects of type Element
template<typename Element, class Policy>
struct queue_concept
{
    // Define interface
    struct const_iterator;
    void push_back(Element e);
    const_iterator begin() const;
    const_iterator end() const;

    // Implementation
private:
    Policy _policy;
};
// implement class methods an inner classes
template<typename Element, class Policy>
struct queue_concept<Element, Policy>::const_iterator
{
    using iterator_type = typename Policy::container_type::const_iterator;
    const_iterator(iterator_type iter = iterator_type {})
    : _iter { std::move(iter) }
    {}
    const Element& operator*() const {
        return *_iter;
    }
    const_iterator& operator++() {
        std::advance(_iter, 1);
    }
    bool operator!=(const const_iterator& other) const {
        return _iter != other._iter;
    }
    iterator_type _iter;
};
template<typename Element, class Policy>
void queue_concept<Element, Policy>::push_back(Element e)
{
    _policy._data.push_back(std::move(e));
}
template<typename Element, class Policy>
typename queue_concept<Element, Policy>::const_iterator queue_concept<Element, Policy>::begin() const
{
    return const_iterator { _policy._data.begin() };
}
template<typename Element, class Policy>
typename queue_concept<Element, Policy>::const_iterator queue_concept<Element, Policy>::end() const
{
    return const_iterator { _policy._data.end() };
}
/// RUNTIME Polymorphic queue of objects of type Element
template<typename Element>
struct IQueue
{
    struct const_iterator
    {
        struct Concept {
            // virtual base class so make destructor virtual...
            virtual ~Concept() = default;
            virtual const Element& get_element() const = 0;
            virtual void increment(std::size_t distance) = 0;
            bool equal_to(const Concept& rhs)
            {
                if (this->get_type() == rhs.get_type()) {
                    return unsafe_is_equal(rhs);
                }
                return false;
            }
            virtual bool unsafe_is_equal(const Concept& rhs) const = 0;
            virtual std::type_index get_type() const = 0;
            // provide copy support
            virtual std::unique_ptr<Concept> clone() const = 0;
        };
        template<class Iter>
        struct Model : public Concept {
            Model(Iter iter) : _iter { std::move(iter) }
            {}
            const Element& get_element() const override {
                return *_iter;
            }
            void increment(std::size_t distance) override {
                std::advance(_iter, distance);
            }
            bool unsafe_is_equal(const Concept& rhs) const override {
                auto _rhs = static_cast<const Model&>(rhs);
                return _iter == _rhs._iter;
            }
            std::type_index get_type() const override {
                return std::type_index(typeid(*this));
            }
            std::unique_ptr<Concept> clone() const override {
                return std::unique_ptr<Concept> { new Model(*this) };
            }
        private:
            Iter _iter;    
        };
        // constructor
        template<class Iter>
        const_iterator(Iter iter)
        : _impl { new Model<Iter> { std::move(iter) } }
        {}
        // default constructor - constructs an invalid iterator
        const_iterator()
        {}
        // provide copy support since impl is a unique_ptr
        const_iterator(const const_iterator& other)
        : _impl { other._impl ? other._impl->clone() : std::unique_ptr<Concept>{} }
        {}
        const_iterator& operator=(const_iterator& other)
        {
            auto p = other._impl ? other._impl->clone() : std::unique_ptr<Concept>{};
            std::swap(_impl, p);
        }
        // since we provided copy support we must provide move support
        const_iterator(const_iterator&& rhs) = default;
        const_iterator& operator=(const_iterator&& rhs) = default;
        const Element& operator*() const {
            return _impl->get_element();
        }
        const_iterator& operator++() {
            _impl->increment(1);
            return *this;
        }
        bool operator!=(const const_iterator& rhs) const
        {
            return !(_impl->equal_to(*(rhs._impl)));
        }
    private:
        std::unique_ptr<Concept> _impl;
    };

    virtual void push_back(Element e) = 0;
    virtual const_iterator begin() const = 0;
    virtual const_iterator end() const = 0;
};

template<class Element, class Policy>
struct QueueImpl : public IQueue<Element>
{
    void push_back(Element e) override {
        _policy._data.push_back(std::move(e));
    }
    typename IQueue<Element>::const_iterator begin() const override {
        return typename IQueue<Element>::const_iterator { std::begin(_policy._data) };
    }
    typename IQueue<Element>::const_iterator end() const override {
        return typename IQueue<Element>::const_iterator { std::end(_policy._data) };
    }

    Policy _policy;
};
template<class Element>
struct ResizingArrayPolicy
{
    using container_type = std::vector<Element>;
    container_type _data;
};
template<class Element>
struct LinkedListPolicy
{
    using container_type = std::list<Element>;
    container_type _data;
};
template<class Element>
std::unique_ptr<IQueue<Element>> make_poly_resizing_array_queue()
{
    return std::unique_ptr<IQueue<Element>> { new QueueImpl<Element, ResizingArrayPolicy<Element>> };
}
template<class Element>
std::unique_ptr<IQueue<Element>> make_poly_linked_list_queue()
{
    return std::unique_ptr<IQueue<Element>> { new QueueImpl<Element, LinkedListPolicy<Element>>{} };
}
template<class Element>
queue_concept<Element, ResizingArrayPolicy<Element>> make_static_resizing_array_queue()
{
    return queue_concept<Element, ResizingArrayPolicy<Element>>{};
}
template<class Element>
queue_concept<Element, LinkedListPolicy<Element>> make_static_linked_list_queue()
{
    return queue_concept<Element, LinkedListPolicy<Element>>{};
}
using namespace std;
int main()
{
    // create the queues
    auto pq1 = make_poly_resizing_array_queue<int>();
    auto pq2 = make_poly_linked_list_queue<int>();
    // put data in them    
    pq1->push_back(10);
    pq1->push_back(20);
    pq2->push_back(30);
    pq2->push_back(40);
    // prove that iterators are assignable and moveable
    IQueue<int>::const_iterator it;
    it = pq1->begin();
    cout << *it << endl; // should print 10
    auto i2 = pq2->begin();
    it = move(i2);
    cout << *it << endl; // should print 30
    // prove that queues are polymorphic
    auto queues = vector<unique_ptr<IQueue<int>>>{};
    queues.push_back(move(pq1));
    queues.push_back(move(pq2));
    // print the vector of queues
    for(const auto& queue_ptr : queues) {
        for(const auto& item : *queue_ptr) {
            cout << item << endl;
        }
        cout << endl;
    }
    // now the static versions
    auto q1 = make_static_resizing_array_queue<int>();
    auto q2 = make_static_linked_list_queue<int>();
    q1.push_back(10);
    q1.push_back(20);
    q2.push_back(30);
    q2.push_back(40);
    cout << "static queuesn";
    for(const auto& item : q1) {
        cout << item << endl;
    }
    cout << endl;    
    for(const auto& item : q2) {
        cout << item << endl;
    }
    return 0;
}

尚不清楚您是否实际需要运行时多态性（例如什么？）

一种方法可以与C 容器使用的方法相似：有一个可以管理对象的分配/交易和构造/构造/破坏的类。

template <typename T, class Allocator> 
class Queue
{
     Allocator myAllocator;
 public:
        void enqueue(T item) 
        {
            myAllocator.push(item);
        }
       // other operations.        
};

，然后有类似

template <class T, template <typename ...> class Container, class ... Args>
class BasicAllocator
{
      Container<T, Args...> M_list;
public:     
      void push(T element)
      {
          M_list.push_back(element);
      }
      auto begin() -> decltype( std::begin(M_list) )
      { return std::begin(M_list); }
      auto end()   -> decltype( std::end(M_list) )
      { return std::end(M_list); }
};
template<class T>
using LinkedListAllocator = BasicAllocator<T, std::list>;
template<class T>
using LinkedListQueue = Queue<T, LinkedListAllocator<T>>;

实施dequeue可能有点棘手。
实例示例