c – const,span和iterator麻烦

2023年7月15日 162次阅读

我尝试编写一个迭代器,通过索引迭代容器.

A It和const它都允许更改容器的内容.

Const_it和const Const_it都禁止更改容器的内容.

之后,我尝试写一个span< T>在一个容器上.
对于不是const的类型T,两个const span< T>并且跨度< T>允许更改容器的内容.
const span< const T>和span< const T>禁止更改容器的内容.

代码无法编译,因为：

    // *this is const within a const method
    // But It<self_type> requires a non-const *this here.
    // So the code does not compile
    It<self_type> begin() const { return It<self_type>(*this, 0); }

如果我使It的构造函数接受一个const容器,它看起来不正确,因为迭代器可以修改容器的内容.

如果我摆脱了方法的const,那么对于非const类型T,const span< T>无法修改容器.

它继承自Const_it,以允许在模板实例化期间从It到Const_it的隐式转换.

我在迭代器(const C * container_;)中使用指针而不是引用来允许将一个迭代器分配给另一个迭代器.

我怀疑这里有些不对劲,因为我甚至想到：

Does cast away const of *this cause undefined behavior?

但我不知道如何解决它.

测试：

#include <vector>
#include <numeric>
#include <iostream>

template<typename C>
class Const_it {
    typedef Const_it<C> self_type;
public:
    Const_it(const C& container, const int ix)
            : container_(&container), ix_(ix) {}
    self_type& operator++() {
        ++ix_;
        return *this;
    }

    const int& operator*() const {
        return ref_a()[ix_];
    }

    bool operator!=(const self_type& rhs) const {
        return ix_ != rhs.ix_;
    }

protected:
    const C& ref_a() const { return *container_; }
    const C* container_;
    int ix_;
};

template<typename C>
class It : public Const_it<C> {
    typedef Const_it<C> Base;
    typedef It<C> self_type;
public:
    //It(const C& container.
    It(C& container, const int ix)
            : Base::Const_it(container, ix) {}
    self_type& operator++() {
        ++ix_;
        return *this;
    }

    int& operator*() const {
        return mutable_a()[ix_];
    }

private:
    C& mutable_a() const { return const_cast<C&>(ref_a()); }
    using Base::ref_a;
    using Base::container_;
    using Base::ix_;
};


template <typename V>
class span {
    typedef span<V> self_type;
public:
    explicit span(V& v) : v_(v) {}
    It<self_type> begin() { return It<self_type>(*this, 0); }
    // *this is const within a const method
    // But It<self_type> requires a non-const *this here.
    // So the code does not compile
    It<self_type> begin() const { return It<self_type>(*this, 0); }
    It<self_type> end() { return It<self_type>(*this, v_.size()); }
    It<self_type> end() const { return It<self_type>(*this, v_.size()); }

    int& operator[](const int ix) {return v_[ix];}
    const int& operator[](const int ix) const {return v_[ix];}
private:
    V& v_;
};


int main() {
    typedef std::vector<int> V;
    V v(10);
    std::iota(v.begin(), v.end(), 0);
    std::cout << v.size() << "\n";
    const span<V> s(v);
    for (auto&& x : s) {
        x = 4;
        std::cout << x << "\n";
    }
}

最佳答案 有两个主要的注意事项要说这项工作.第一：

If I make the constructor of It to accept a const container, it doesn’t look right because the iterator can modify the content of the container.

不是真的,因为模板中的C< typename C> class它不是实际的容器,而是跨度< V>.换句话说,看看：

It<self_type> begin() const { return It<self_type>(*this, 0); }

这里self_type表示const span< V>,因此您返回It< const span< V>>.因此,你的迭代器可以用const span做任何事情 – 但容器仍然是非const的.变量名称container_不是幸运的.

For a type T that is not const, both const span<T> and span<T> allows changing the content of the container. Both const span<const T> and span<const T> forbid changing the content of the container.

另外,既然你想让const span允许修改内容,那么你应该在span内部写的是(注意const)：

int& operator[](const int ix) const {return v_[ix];}
// Removing the other `const` version:
// const int& operator[](const int ix) const {return v_[ix];}

通过澄清这两个位,您可以构建一个工作示例.这是一个基于您的代码并简化以解决手头的问题：

#include <vector>
#include <iostream>

template<typename S>
class It {
    typedef It<S> self_type;
    const S& span_;
    int ix_;

public:
    It(const S& span, const int ix)
        : span_(span), ix_(ix) {}

    self_type& operator++() {
        ++ix_;
        return *this;
    }

    int& operator*() const {
        return span_[ix_];
    }

    bool operator!=(const self_type& rhs) const {
        return &span_ != &rhs.span_ or ix_ != rhs.ix_;
    }
};

template <typename V>
class span {
    typedef span<V> self_type;
public:
    explicit span(V& v) : v_(v) {}
    It<self_type> begin() const { return It<self_type>(*this, 0); }
    It<self_type> end() const { return It<self_type>(*this, v_.size()); }

    int& operator[](const int ix) const {return v_[ix];}
private:
    V& v_;
};

int main() {
    typedef std::vector<int> V;
    V v(10);
    const span<V> s(v);
    for (auto&& x : s) {
        x = 4;
        std::cout << x << "\n";
    }
}

看一下operator！=的更正实现,以及不需要非const版本的begin()和end()这一事实.你也可以扔一个cbegin()和cend().然后你必须处理添加const迭代器的情况.

顺便说一句,如果它为任何人节省了一些混乱：在不久的将来,可能会增加std::span(proposed for C++20);它只是一个(指向第一个元素的索引)对 – 而不是你的(指向容器,索引)索引版本.

换句话说,作为模板参数,它将采用元素的类型,而不是容器：

span<std::vector<int>> s(v);
// vs
std::span<int> s(v);

这允许std :: span的使用者避免知道幕后的容器(甚至没有容器：连续的内存区域或数组).

最后,您可能需要查看GSL’s implementation of std::span以获得有关如何完全实现它的一些灵感(包括关于范围的第二个模板参数).

点赞