作为这个问题Are const_iterators faster? 的扩展，我还有一个关于const_iterators 的问题。如何删除const_iterator 的常量？
尽管迭代器是指针的广义形式，但 const_iterator 和 iterators 仍然是两个不同的东西。因此，我相信，我也不能使用const_cast<> 将const_iterator 转换为iterators。
一种方法可能是定义一个迭代器，它移动'直到const_iterator 指向的元素。但这看起来是一个线性时间算法。
您知道实现这一目标的最佳方法是什么吗？
【问题讨论】：
标签： c++ stl iterator const-iterator
在 C++11 中有一个恒定时间复杂度的解决方案：对于任何序列、关联或无序关联容器（包括所有标准库容器），您都可以调用具有空范围的范围擦除成员函数：
template <typename Container, typename ConstIterator>
typename Container::iterator remove_constness(Container& c, ConstIterator it)
{
return c.erase(it, it);
}
范围擦除成员函数有一对const_iterator 参数，但它们返回一个iterator。因为提供了一个空范围，所以对擦除的调用不会更改容器的内容。
【讨论】：
erase 实际上并不是容器要求的一部分，因此它不一定适用于满足容器要求的所有用户定义类型。您已经在答案中说过这一点，但是将“无序关联”添加到括号中的列表中。也许这种迂腐应该适用于您对 Visage 答案的评论，您在其中说“所有容器”，而不是您的完整答案。
erase 调用暗示了某些容器的潜在迭代器和引用失效。当然，空范围不应该发生这种情况，但是某些 b̶r̶a̶i̶n̶-d̶e̶a̶d̶ 实现（例如 VS2017 的实现）可能会触发断言错误。
不幸的是，线性时间是唯一的方法：
iter i(d.begin());
advance (i,distance<ConstIter>(i,ci));
其中 iter 和 constIter 是合适的 typedef，d 是您正在迭代的容器。
【讨论】：
iter i(d.begin()); while (ConstIter(i) != ci) ++i; 会更有效。仍然令人失望，但至少它只从i 向前走一次。您可以使用 iterator-type-tag 分派来编写函数模板，这些模板实际上对迭代器类型进行了重载，至少它们会假设迭代器被正确标记。
begin() 在某些情况下使迭代器无效的措辞已被删除，因此在 C++11 中 begin() 不再使迭代器无效。
在您上一篇文章的答案中，有几个人（包括我）建议使用 const_iterators 而不是性能相关的原因。可读性，从设计板到代码的可追溯性......使用 const_iterators 提供对非常量元素的变异访问比根本不使用 const_iterators 要糟糕得多。你正在将你的代码转换成只有你能理解的东西，设计更差，可维护性也很痛苦。使用 const 只是为了抛弃它比根本不使用 const 要糟糕得多。
如果你确定你想要它，C++ 的好/坏部分是你总是可以得到足够的绳子来吊死自己。如果您打算使用 const_iterator 来解决性能问题，那么您真的应该重新考虑它，但如果您仍然想大吃一惊……那么 C++ 可以提供您选择的武器。
首先，最简单的：如果您的操作将参数作为 const（即使在内部应用 const_cast）我相信它应该在大多数实现中直接工作（即使它可能是未定义的行为）。
如果您无法更改函子，那么您可以从任一方面解决问题：在 const 迭代器周围提供一个非常量迭代器包装器，或者在非常量函子周围提供一个 const 函子包装器。
迭代器外观，漫漫长路：
template <typename T>
struct remove_const
{
typedef T type;
};
template <typename T>
struct remove_const<const T>
{
typedef T type;
};
template <typename T>
class unconst_iterator_type
{
public:
typedef std::forward_iterator_tag iterator_category;
typedef typename remove_const<
typename std::iterator_traits<T>::value_type
>::type value_type;
typedef value_type* pointer;
typedef value_type& reference;
unconst_iterator_type( T it )
: it_( it ) {} // allow implicit conversions
unconst_iterator_type& operator++() {
++it_;
return *this;
}
value_type& operator*() {
return const_cast<value_type&>( *it_ );
}
pointer operator->() {
return const_cast<pointer>( &(*it_) );
}
friend bool operator==( unconst_iterator_type<T> const & lhs,
unconst_iterator_type<T> const & rhs )
{
return lhs.it_ == rhs.it_;
}
friend bool operator!=( unconst_iterator_type<T> const & lhs,
unconst_iterator_type<T> const & rhs )
{
return !( lhs == rhs );
}
private:
T it_; // internal (const) iterator
};
【讨论】：
Scott Meyer's article 选择迭代器而不是 const_iterators 回答了这个问题。 Visage 的答案是唯一安全的 C++11 之前的替代方案，但实际上对于实现良好的随机访问迭代器来说是恒定时间，而对于其他迭代器来说是线性时间。
【讨论】：
这可能不是您想要的答案，但有些相关。
我假设你想改变迭代器指向的东西。我做的最简单的方法是 const_cast 代替返回的引用。
类似的东西
const_cast<T&>(*it);
【讨论】：
我相信设计良好的程序不需要这种转换。
如果您需要这样做 - 尝试重新设计代码。
您可以使用以下解决方法：
typedef std::vector< size_t > container_type;
container_type v;
// filling container code
container_type::const_iterator ci = v.begin() + 3; // set some value
container_type::iterator i = v.begin();
std::advance( i, std::distance< container_type::const_iterator >( v.begin(), ci ) );
但我认为有时这种转换是不可能的，因为您的算法无法访问容器。
【讨论】：
您可以从 const_iterator 中减去 begin() 迭代器以获得 const_iterator 指向的位置，然后将 begin() 加回到该位置以获得非常量迭代器。我不认为这对于非线性容器会非常有效，但对于向量等线性容器，这将需要恒定的时间。
vector<int> v;
v.push_back(0);
v.push_back(1);
v.push_back(2);
v.push_back(3);
vector<int>::const_iterator ci = v.begin() + 2;
cout << *ci << endl;
vector<int>::iterator it = v.begin() + (ci - v.begin());
cout << *it << endl;
*it = 20;
cout << *ci << endl;
编辑：这似乎只适用于线性（随机访问）容器。
【讨论】：
您可以将您的 const 迭代器值指针转换为非 const 值指针并直接使用它
vector<int> v;
v.push_back(0);
v.push_back(1);
v.push_back(2);
v.push_back(2);
vector<int>::const_iterator ci = v.begin() + 2;
cout << *ci << endl;
*const_cast<int*>(&(*ci)) = 7;
cout << *ci << endl;
【讨论】：
std::vector 和其他具有连续存储的容器“有效”，但不适用于其他容器（如std::list）。
我认为想出一个适用于不在标准库中且不包含 erase() 方法的容器的解决方案会很有趣。
尝试使用它会导致 Visual Studio 2013 挂起编译。我不包括测试用例，因为将其留给能够快速找出界面的读者似乎是个好主意；我不知道为什么这会挂在编译上。即使 const_iterator 等于 begin() 也会发生这种情况。
// deconst.h
#ifndef _miscTools_deconst
#define _miscTools_deconst
#ifdef _WIN32
#include <Windows.h>
#endif
namespace miscTools
{
template < typename T >
struct deconst
{
static inline typename T::iterator iterator ( typename T::const_iterator*&& target, T*&& subject )
{
typename T::iterator && resultant = subject->begin ( );
bool goodItty = process < 0, T >::step ( std::move ( target ), std::move ( &resultant ), std::move ( subject ) );
#ifdef _WIN32
// This is just my habit with test code, and would normally be replaced by an assert
if ( goodItty == false )
{
OutputDebugString ( " ERROR: deconst::iterator call. Target iterator is not within the bounds of the subject container.\n" )
}
#endif
return std::move ( resultant );
}
private:
template < std::size_t i, typename T >
struct process
{
static inline bool step ( typename T::const_iterator*&& target, typename T::iterator*&& variant, T*&& subject )
{
if ( ( static_cast <typename T::const_iterator> ( subject->begin () + i ) ) == *target )
{
( *variant ) += i;
return true;
}
else
{
if ( ( *variant + i ) < subject->end () )
{
process < ( i + 1 ), T >::step ( std::move ( target ), std::move ( variant ), std::move ( subject ) );
}
else { return false; }
}
}
};
};
}
#endif
【讨论】：