C++ C++；：多态容器/迭代器与编译时概念/特征

背景

这纯粹是为了教育目的。如果你不想阅读整个背景，你可以跳到底部的问题

我已经编写了一个队列接口（抽象类），以及两个基于调整数组和链表大小的派生实现

template <typename T>
class IQueue {
public:
  virtual void enqueue(T item) = 0;
  virtual T dequeue() = 0;
  virtual bool isEmpty() = 0;
  virtual int size() = 0;
}

template <typename T>
class LinkedListQueue : public IQueue<T> {...}

template <typename T>
class ResizingArrayQueue : public IQueue<T> {...}

其中一个派生类实现了

begin（）

/

end（）

方法和派生迭代器实现：

template <typename T>
class LinkedListQueue : public IQueue<T> {
// ... queue implementation details.
public:
    class LinkedListForwardIterator : public IQueue<T>::IteratorImpl {
    // ... implementation that goes through linked list.
    };

    typename IQueue<T>::ClientIterator begin() {
        std::unique_ptr<LinkedListForwardIterator> impl(new LinkedListForwardIterator(head));
        return typename IQueue<T>::iterator(std::move(impl));
    }

    typename IQueue<T>::ClientIterator end() {
        std::unique_ptr<LinkedListForwardIterator> impl(new LinkedListForwardIterator(nullptr));
        return typename IQueue<T>::iterator(std::move(impl));
    }
};

下面是一个最低限度的可编译示例，说明您可能希望如何执行此操作

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

添加更多的方法和可变迭代器对于读者来说是一个练习

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

#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 queues\n";
    for(const auto& item : q1) {
        cout << item << endl;
    }
    cout << endl;    
    for(const auto& item : q2) {
        cout << item << endl;
    }

    return 0;
}

#包括
#包括
#包括
#包括
#包括
#包括
///元素类型的对象的编译时多态队列
模板
结构队列概念
{
//定义接口
结构常量迭代器；
无效推回（元素e）；
常量迭代器begin（）常量；
常量迭代器end（）常量；
//实施
私人：
政策(政策),；
};
//在内部类中实现类方法
模板
结构队列概念：：常量迭代器
{
使用迭代器\类型=类型名策略：：容器\类型：：常量\迭代器；
常量迭代器（迭代器类型iter=迭代器类型{}）
：_iter{std:：move（iter）}
{}
常量元素和运算符*（）常量{
返回*\u iter；
}
常量迭代器和运算符++（）{
标准：国际热核实验堆1号；
}
布尔运算符！=（常量迭代器和其他）常量{
返回_iter！=其他。_iter；
}
迭代器类型；
};
模板
无效队列概念：：推回（元素e）
{
_策略._data.push_back（std:：move（e））；
}
模板
typename队列概念：：常量迭代器队列概念：：begin（）常量
{
返回常量迭代器{u policy.\u data.begin（）}；
}
模板
typename队列概念：：常量迭代器队列概念：：end（）常量
{
返回常量迭代器{u policy.\u data.end（）}；
}
///元素类型的对象的运行时多态队列
模板
伊奎厄结构
{
结构常量迭代器
{
结构概念{
//虚拟基类使析构函数虚拟。。。
virtual~Concept（）=默认值；
虚拟常量元素&get_元素（）常量=0；
虚拟空隙增量（标准：：尺寸距离）=0；
布尔等于（常数概念和rhs）
{
if（this->get_type（）==rhs.get_type（））{
返回值等于（rhs）；
}
返回false；
}
虚拟布尔不安全等于（常数概念和rhs）常数=0；
虚拟std:：type_index get_type（）const=0；
//提供拷贝支持
虚拟std:：unique_ptr clone（）const=0；
};
模板
结构模型：公共概念{
模型（国际热核实验堆）：国际热核实验堆{std:：move（国际热核实验堆）}
{}
常量元素&get_Element（）常量覆盖{
返回*\u iter；
}
无效增量（标准：：大小\u t距离）覆盖{
标准：前进（_iter，距离）；
}
布尔不安全等于（常数概念和rhs）常数覆盖{
自动旋转=静态旋转（rhs）；
return(返回)iter==(返回)；
}
std:：type_index get_type（）常量重写{
返回std：：type_索引（typeid（*this））；
}
std:：unique_ptr clone（）常量覆盖{
返回std:：unique_ptr{newmodel（*this）}；
}
私人：
国际热核实验堆；
};
//建造师
模板
常量迭代器（Iter）
：_impl{new Model{std:：move（iter）}
{}
//默认构造函数-构造无效的迭代器
常量迭代器（）
{}
//提供拷贝支持，因为impl是唯一的\u ptr
常量迭代器（常量迭代器和其他）
：_impl{other._impl？other._impl->clone（）：std:：unique_ptr{}
{}
常量迭代器和运算符=（常量迭代器和其他）
{
auto p=other.\u impl？other.\u impl->clone（）：std:：unique\u ptr{}；
标准：：交换（_impl，p）；
}
//既然我们提供了复制支持，我们就必须提供移动支持
常量迭代器（常量迭代器&&rhs）=默认值；
常量迭代器和运算符=（常量迭代器和rhs）=默认值；
常量元素和运算符*（）常量{
返回_impl->get_元素（）；
}
常量迭代器和运算符++（）{
_impl->increment（1）；
归还*这个；
}
布尔运算符！=（常量迭代器和rhs）常量
{
返回！（_impl->等于（*（rhs._impl））；
}
私人：
std：：唯一的\u ptr\u impl；
};
虚空推回（元素e）=0；
虚拟常量迭代器begin（）常量=0；
虚拟常量迭代器end（）常量=0；
};
模板
结构QueueImpl:公共IQueue
{
无效推回（元素e）覆盖{
_策略._data.push_back（std:：move（e））；
}
typename IQueue:：常量迭代器begin（）常量重写{
返回typename IQueue:：const_迭代器{std:：begin（_policy._data）}；
}
typename IQueue:：常量迭代器end（）常量重写{
返回typename IQueue:：const_迭代器{std:：end（_policy._data）}；
}
政策(政策),；
};
模板
结构调整大小策略
{
使用容器_type=std:：vector；
容器类型数据；
};
模板
结构LinkedListPolicy
{
使用容器类型=标准：：列表；
容器类型数据；
};
模板
std:：unique_ptr make_poly_resizing_array_queue（）
{
返回std:：unique_ptr{new QueueImpl}；
}
模板
std:：唯一的\u ptr生成\u多边形\u链接的\u列表\u队列（）
{
返回
template <typename T>
void testQueueImpl(std::shared_ptr<IQueue<T> > queue) {
    queue->enqueue(1);
    queue->enqueue(2);
    queue->enqueue(3);
    queue->enqueue(4);
    queue->enqueue(5);
    queue->enqueue(6);

    std::cout << "Iterator behavior check 1st: ";
    for (auto e: *queue) {
        std::cout << e << " ";
    }
    std::cout << std::endl;

    std::cout << "Iterator behavior check 2nd: ";
    for (auto it = queue->begin(); it != queue->end(); it++) {
        std::cout << *it << " ";
    }
}

void testQueue() {
    auto queue = std::make_shared<LinkedListQueue<int> >();
    testQueueImpl<int>(queue);

    auto queue2 = std::make_shared<ResizingArrayQueue<int> >();
    testQueueImpl<int>(queue2);
}

template <typename Container>
void testQueueImpl(Container queue) {
    queue->enqueue(1);
    queue->enqueue(2);
    queue->enqueue(3);
    queue->enqueue(4);
    queue->enqueue(5);
    queue->enqueue(6);

    std::cout << "Size: " << queue->size() << std::endl;

    std::cout << "Iterator behavior check 1st: ";
    for (auto e: *queue) {
        std::cout << e << " ";
    }
    std::cout << std::endl;

    std::cout << "Iterator behavior check 2nd: ";
    for (auto it = queue->begin(); it != queue->end(); it++) {
        std::cout << *it << " ";
    }
    std::cout << std::endl;
}

void testQueue() {
    auto queue = std::make_shared<LinkedListQueue<int> >();
    testQueueImpl<std::shared_ptr<LinkedListQueue<int> > >(queue);

    auto queue2 = std::make_shared<ResizingArrayQueue<int> >();
    testQueueImpl<std::shared_ptr<ResizingArrayQueue<int> > >(queue2);
}

#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 queues\n";
    for(const auto& item : q1) {
        cout << item << endl;
    }
    cout << endl;    
    for(const auto& item : q2) {
        cout << item << endl;
    }

    return 0;
}

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>>;