typedefed as std::vector<const std::shared_ptr<MyClass>>::iterator（应该与std::vector<std::shared_ptr<const MyClass>>::const_iterator
但它可能不是同一类型。迭代器不仅仅是指针。如果iteratorandconst_iterator类型在内部定义，vector那么它们是完全不相关的类型：
template<typename T>
class vector
{
class iterator;
class const_iterator;
// ...
vector<const int>是不同的类型vector<int>，因此它们的嵌套类型也不同。就编译器而言，它们是完全不相关的类型，即您不能只移动const到此类型的任何点并获得兼容的类型：
vector<const shared_ptr<const T>>::iterator
您不能用于const_cast在不相关的类型之间进行转换。您可以使用static_cast将 a 转换vector<T>::iterator为 avector<T>::const_iterator但它不是真正的演员，您正在从前者构造后者，这是允许的，因为标准要求进行转换。
您可以将 a 转换shared_ptr<const T>为 a shared_ptr<T>with const_pointer_cast<T>but 只是因为它被定义为按标准工作，而不是因为这些类型本质上是兼容的，也不是因为它像普通的 ol' 指针一样“工作”。
由于vector's 的迭代器不能提供你想要的深度常量，你需要自己编写，但这并不难：
class MyClass { };
class MyContainer
{
typedef std::vector<std::shared_ptr<MyClass>> container_type;
container_type m_cont;
public:
typedef container_type::iterator iterator;
class const_iterator
{
typedef container_type::const_iterator internal_iterator;
typedef std::iterator_traits<internal_iterator> internal_traits;
const_iterator(internal_iterator i) : m_internal(i) { }
friend class MyContainer;
public:
const_iterator() { }
const_iterator(iterator i) : m_internal(i) { }
typedef std::shared_ptr<const MyClass> value_type;
typedef const value_type& reference;
typedef const value_type* pointer;
typedef internal_traits::difference_type difference_type;
typedef internal_traits::iterator_category iterator_category;
const_iterator& operator++() { ++m_internal; return *this; }
const_iterator operator++(int) { const_iterator tmp = *this; ++m_internal; return tmp; }
reference operator*() const { m_value = *m_internal; return m_value; }
pointer operator->() const { m_value = *m_internal; return &m_value; }
// ...
private:
internal_iterator m_internal;
mutable value_type m_value;
};
iterator begin() { return m_cont.begin(); }
const_iterator begin() const { return const_iterator(m_cont.begin()); }
// ...
};
该迭代器类型缺少一些东西（operator--, operator+），但它们很容易添加，遵循与已经显示的相同的想法。
需要注意的关键点是，为了const_iterator::operator*返回引用，需要有一个shared_ptr<const MyClass>对象存储为迭代器的成员。该成员充当该shared_ptr<const MyClass>值的“缓存”，因为底层容器的真实元素是不同的类型，shared_ptr<MyClass>因此您需要在某个地方缓存转换后的值，以便可以返回对它的引用。NB 这样做会稍微破坏迭代器的要求，因为以下内容无法按预期工作：
MyContainer::const_iterator ci = c.begin();
const shared_ptr<const MyClass>& ref = *ci;
const MyClass* ptr = ref.get();
++ci;
(void) *ci;
assert( ptr == ref.get() ); // FAIL!
断言失败的原因是*ci它没有返回对容器底层元素的引用，而是返回到迭代器的成员，该迭代器通过以下增量和取消引用进行修改。如果这种行为不可接受，您将需要从迭代器返回一个代理，而不是缓存一个值。或者在取消引用shared_ptr<const MyClass>时返回 a 。const_iterator（获得 100% 正确的困难是 STL 容器不尝试对深度常量建模的原因之一！）
定义您自己的迭代器类型的许多工作都是由该boost::iterator_adaptor 实用程序为您完成的，因此上面的示例仅对说明有用。使用该适配器，您只需执行此操作即可获得具有所需行为的自定义迭代器类型：
struct iterator
: boost::iterator_adaptor<iterator, container_type::iterator>
{
iterator() { }
iterator(container_type::iterator i) : iterator_adaptor(i) { }
};
struct const_iterator
: boost::iterator_adaptor<const_iterator, container_type::const_iterator, std::shared_ptr<const MyClass>, boost::use_default, std::shared_ptr<const MyClass>>
{
const_iterator() { }
const_iterator(iterator i) : iterator_adaptor(i.base()) { }
const_iterator(container_type::const_iterator i) : iterator_adaptor(i) { }
};