使用迭代器检索容器中指向的 const 值

Answer 1

根据您的情况，听起来像定义具有所需语义的自定义迭代器是安全且简单的方法。它在技术上是正确的，很难意外误用，而且速度相当快，只需要在迭代器取消引用时复制 shared_ptr 即可。

我总是推荐boost::iterator_facade 或boost::iterator_adaptor 来创建迭代器类型。因为它将包含原始的 vector 迭代器作为“基础”实现，所以 iterator_adaptor 很有帮助。

class const_Thing_ptr_iterator :
    public boost::iterator_adaptor<
        const_Thing_ptr_iterator,                            // CRTP derived type
        std::vector<std::shared_ptr<Thing>>::const_iterator, // base iterator type
        std::shared_ptr<const Thing>,                        // value_type
        std::random_access_iterator_tag,                     // traversal type
        std::shared_ptr<const Thing>                         // reference
    >
{
public:
    const_Thing_ptr_iterator() = default;
    explicit const_Thing_ptr_iterator(base_type iter)
        : iterator_adaptor(iter) {}
};

reference 迭代器类型默认为std::shared_ptr<const Thing>&，但在这种情况下它不能是引用，因为没有该类型的对象。通常该类会定义一些行为函数，如dereference 或increment，但这里不需要：从基本向量迭代器到返回类型的唯一变化是operator*，默认reference dereference() const { return *base_reference(); } 有效从const std::shared_ptr<Thing>& 到std::shared_ptr<const Thing> 的隐式转换很好。

该类也可以是一个以Thing 作为其类型参数的模板，以创建多个迭代器类型。

然后为了提​​供一个类似容器的视图对象，我们可以使用 C++20 的 std::ranges::subrange 来提供 begin() 和 end() 以及其他一些帮助超出范围模板的东西：

#include <ranges>
class const_Thing_ptrs_view
  : public std::ranges::subrange<const_Thing_ptr_iterator>
{
public:
    explicit const_Thing_ptrs_view(const std::vector<std::shared_ptr<Thing>> &vec)
        : subrange(const_Thing_ptr_iterator(vec.begin()),
                   const_Thing_ptr_iterator(vec.end())) {}
};

或者，如果这不可用，则使用 begin() 和 end() 的简单类：

class const_Thing_ptrs_view {
public:
    explicit const_Thing_ptrs_view(const std::vector<std::shared_ptr<Thing>> &vec)
        : m_begin(vec.begin()), m_end(vec.end()) {}
    const_Thing_ptr_iterator begin() const { return m_begin; }
    const_Thing_ptr_iterator end() const { return m_end; }
private:
    const_Thing_ptr_iterator m_begin;
    const_Thing_ptr_iterator m_end;
};

Demo on godbolt。 （由于this libstdc++ incompatibility，Clang 不喜欢范围代码；我不确定如何让 Godbolt 将其切换到 clang 的 libc++。）

Answer 2

一个非常简单的方法可能是在内部维护一个指向 const 的指针向量 - 并将 const 转换为内部使用。

警告：不要认为这是一个粗心大意的邀请！如果你这样做，在某个时间点你将要打破东西。毕竟这些对象都是 const 是有原因的！

但是，在特定情况下，这个原因是纯粹的外部原因——如果不是公共接口，对象将永远不会得到const，因此再次将其丢弃是有效的在这个非常具体的情况下.

class DataOwner
{
public:
    std::vector<std::shared_ptr<Thing const>> const& data() const
    {
        return m_data;
    }

    void modify()
    {
        m_data.emplace_back(new Thing());

        at(0)->doSomething();
    }

    // for convenience of the user you might optionally duplicate
    // the const interface of `std::vector` here as well

private:
    std::vector<std::shared_ptr<Thing const>> m_data;

    Thing* at(size_t index)
    {
        // only one single location where const-casting
        // remember: generally a dangerous operation,
        // here one of the view valid use cases
        return const_cast<Thing*>(m_data[index].get());
        // don't forget to document in your own code WHY it is valid here
    }
};

Answer 3

将所有共享指针复制到新向量中很快就会变得非常昂贵，尤其是如果原始源向量被频繁更新并且引用实例因此需要一次又一次地获取更新。

因此，我个人宁愿提供一个围绕std::vector 或围绕std::shared_ptr 的包装器，它只向数据所有者（届时将成为朋友）提供修改访问权限，而通用接口只允许非修改访问。但是，包装向量将需要在检索共享指针时复制共享指针，因此涉及引用计数，此外，解决方案变得更加复杂，因此在此处使用共享指针周围的包装器：

struct Thing
{
    void doSomething() { }
    void doSomethingElse() const { }
};

class DataOwner
{
public:
    class SharedPointer
    {
    public:
        SharedPointer(SharedPointer const&) = default;
        SharedPointer(SharedPointer&&) = default;
        SharedPointer& operator=(SharedPointer const&) = default;
        SharedPointer& operator=(SharedPointer&&) = default;

        Thing const& operator*() const
        {
            return *m_data;
        }
        Thing const* operator->() const
        {
            return m_data.get();
        }
        Thing const* get() const
        {
            return m_data.get();
        }

        // should be all of the public interface needed...

    private:
        friend class DataOwner;

        SharedPointer(Thing* t) : m_data(t) { }
        std::shared_ptr<Thing> m_data;
    };

    std::vector<SharedPointer> const& data() const
    {
        return m_data;
    }

    void modify()
    {
        m_data.emplace_back(SharedPointer(new Thing()));

        m_data[0].m_data->doSomething();
        // if needed at many places you might want to have a
        // convenience function, see below...
        at(0)->doSomething();
    }

    // for convenience of the user you might optionally duplicate
    // the const interface of `std::vector` here as well

private:
    std::vector<SharedPointer> m_data;

    Thing* at(size_t index)
    {
        return m_data[index].m_data.get();
    }
};

int main()
{
    DataOwner o;
    o.modify();

    o.data()[0]->doSomethingElse();
    // o.data()[0]->doSomething(); won't compile!

    return 0;
}