如何在 C++ 中为复合容器类实现迭代器答案

【问题标题】：How to implement an iterator for a composite container class in c++如何在 C++ 中为复合容器类实现迭代器
【发布时间】：2015-02-22 08:55:56
【问题描述】：

我正在实现一个容器类，以确保元素之间的唯一性并将插入和删除限制在仅末尾。有点像一堆独特的元素或具有推送和弹出等功能的有序集合。而且它还必须有一个固定的最大尺寸。

template <class T, int max_size>
class FixedSizedUniqueStack
{
    std::vector<T> m_vec;
    std::unordered_set<T> m_uset;
public:
    FixedSizedUniqueStack():m_vec(max_size),m_uset(){}
    bool push(T x)
    {
        bool success = true;
        if( m_uset.insert(x).second ) m_vec.push_back(x);
        else success = false;
        return success;
    }
    void pop()
    {
        if(m_vec.size() > 0)
        {
            m_uset.erase(m_vec.back());
            m_vec.pop_back();
        }
    }
    T back()
    {
        return m_vec.back();
    }
};

【问题讨论】：

为什么你的迭代器不能是std::vector<T>::iterator？
另外，为什么这个问题不是stackoverflow.com/questions/7758580/…的重复？
到底是什么问题？
我希望类可以使用 for 循环进行迭代。

标签： c++

【解决方案1】：

#include <vector>
#include <unordered_set>
#include <initializer_list>
template <class T, int max_size>
class FixedSizedUniqueStack:  public std::initializer_list<T>
{
protected:
    std::vector<T> m_vec;
    std::unordered_set<T> m_uset;
public:
    FixedSizedUniqueStack():m_vec(),m_uset(){}
    FixedSizedUniqueStack( const FixedSizedUniqueStack &x)
    {
        m_vec = x.m_vec;
        m_uset = x.m_uset;
    }
    FixedSizedUniqueStack& operator= ( const FixedSizedUniqueStack &x)
    {
        if (this != &x)
        {
            m_vec = x.m_vec;
            m_uset = x.m_uset;
        }
        return *this;
    }
    auto size() const -> decltype(m_vec.size())
    {
        return m_vec.size();
    }
    int push(const std::initializer_list<T>& il)
    {
        int errors = 0;
        for (auto x: il)
        {
            if( push(x) )
            {
                errors++;
            }
        }
        return errors;
    }
    int push(const T& x)
    {
        int error =0;
        if(m_vec.size() < max_size)
        {
            if( x < start)
            {
                error  = 1;
            }
            else if( x > stop)
            {
                error = 2;
            }
            else
            {
                if( m_uset.insert(x).second ) m_vec.push_back(x);
                else error = 3;
            }
        }
        else
        {
            error = 4;
        }
        return error;
    }
    void pop()
    {
        if(!m_vec.empty())
        {
            m_uset.erase(m_vec.back());
            m_vec.pop_back();
        }
    }
    T back()
    {
        return m_vec.back();
    }
    auto cbegin() const -> decltype(m_vec.cbegin())
    {
        return m_vec.cbegin();
    }
    auto cend() const -> decltype(m_vec.cend())
    {
        return m_vec.cend();
    }

    auto begin() const -> decltype(m_vec.begin())
    {
        return m_vec.begin();
    }
    auto end() const -> decltype(m_vec.end())
    {
        return m_vec.end();
    }

    auto empty() ->decltype(m_vec.empty())
    {
        return m_vec.empty();
    }

【讨论】：