為容器提供只有const迭代器是否有意義？

Question

我有一個類似於下一個的容器：

class MySpecialContainer
{
    std::vector<std::tuple<InternalType, Type1, Type2>> _vec;
};

其中Type1和Type2在容器外部可用，而InternalType僅在容器內使用。 要從外部迭代元素，我使用類似於下一個的成員函數：

void MySpecialContainer::iterate(std::function<void(const Type1&, const Type2&)> fun)
{
    for(auto& it : _vec)
    {
        fun(std::get<1>(it), std::get<2>(it));
    }
}

正如您所看到的，這種方法有一些限制，例如無法迭代子范圍或無法使用非變異std::algorithms 。

考慮到MySpecialContainer元素從邏輯上考慮外部是不可變的，為它提供const_iterator是否有意義？

如果對第一個問題的答案是肯定的，那么......更好嗎？

1. 將_vec分成2個容器，一個用於InternalType ，一個用於std::pair<Type1, Type2> ，保持它們同步，只返回const_iterator用於第二個向量

2. 保持現在的向量，並創建一個自定義迭代器，只顯示const Type1和const Type2

Answer 1

一種選擇是公開迭代器，只允許訪問元素的某些字段，例如：

#include <vector>
#include <tuple>
#include <boost/iterator/transform_iterator.hpp>

struct Type1 {};
struct Type2 {};
struct InternalType {};

class MySpecialContainer
{
    typedef std::vector<std::tuple<InternalType, Type1, Type2>> Vec;
    Vec _vec;

    struct Extractor
    {
        std::tuple<Type1&, Type2&> operator()(Vec::value_type& t) const {
            return std::tie(std::get<1>(t), std::get<2>(t));
        }

        std::tuple<Type1 const&, Type2 const&> operator()(Vec::value_type const& t) const {
            return std::tie(std::get<1>(t), std::get<2>(t));
        }
    };

public:
    typedef boost::transform_iterator<Extractor, Vec::iterator> iterator;
    typedef boost::transform_iterator<Extractor, Vec::const_iterator> const_iterator;

    iterator begin() { return iterator{_vec.begin()}; }
    iterator end() { return iterator{_vec.end()}; }
    const_iterator begin() const { return const_iterator{_vec.begin()}; }
    const_iterator end() const { return const_iterator{_vec.end()}; }
};

int main() {
    MySpecialContainer c;
    for(auto x : c) {
    }
}

請注意，通過非const迭代器，您仍然可以更新公開的值，因為trasform迭代器返回一個引用元組。

Answer 2

只是公開const迭代器就可以了。 標准中甚至有優先權，因為std::set有效地做到了這一點。 從技術上講， iterator和const_iterator可以是不同的類型，但是不允許通過任何類型的迭代器修改元素，因為這可能會破壞set的不變量。