C++ 中的 const_iterator 和非常量迭代器有什么区别？ 标准格式？

Question

const_iterator 和 iterator 之间有什么区别？您会在哪里使用其中一个？

Answer 1

const_iterator 不允许您更改它们指向的值，而常规迭代器则可以。

与 C++ 中的所有事物一样，总是更喜欢 const，除非有充分的理由使用常规迭代器（即您想利用它们不是 const 的事实来更改指向的值）。

Answer 2

它们应该是不言自明的。 如果 iterator 指向 T 类型的元素，则 const_iterator 指向“const T”类型的元素。

它基本上等同于指针类型：

T* // A non-const iterator to a non-const element. Corresponds to std::vector<T>::iterator
T* const // A const iterator to a non-const element. Corresponds to const std::vector<T>::iterator
const T* // A non-const iterator to a const element. Corresponds to std::vector<T>::const_iterator

const 迭代器总是指向同一个元素，因此迭代器本身是const。 但它指向的元素不必是const，因此它指向的元素是可以改变的。
const_iterator 是一个指向 const 元素的迭代器，因此虽然迭代器本身可以更新（例如递增或递减），但它指向的元素不能更改。

Answer 3

最小可运行示例

非常量迭代器允许您修改它们指向的内容：

std::vector<int> v{0};
std::vector<int>::iterator it = v.begin();
*it = 1;
assert(v[0] == 1);

常量迭代器不允许：

const std::vector<int> v{0};
std::vector<int>::const_iterator cit = v.begin();
// Compile time error: cannot modify container with const_iterator.
//*cit = 1;

如上所示，v.begin() 是 const 重载，并根据容器变量的 const 性返回 iterator 或 const_iterator：

• begin() 如何知道要返回哪种返回类型（const 或非 const）？
• const 和 non- 的重载如何const 函数有效吗？

弹出 const_iterator 的常见情况是在 const 方法内使用 this 时：

class C {
    public:
        std::vector<int> v;
        void f() const {
            std::vector<int>::const_iterator it = this->v.begin();
        }
        void g(std::vector<int>::const_iterator& it) {}
};

const 使 this 成为常量，从而使 this->v 成为常量。

您通常可以使用 auto 忘记它，但如果您开始传递这些迭代器，您将需要考虑它们的方法签名。

与 const 和非常量非常相似，您可以轻松地从非常量转换为 const，但反之则不然：

std::vector<int> v{0};
std::vector<int>::iterator it = v.begin();

// non-const to const.
std::vector<int>::const_iterator cit = it;

// Compile time error: cannot modify container with const_iterator.
//*cit = 1;

// Compile time error: no conversion from const to no-const.
//it = ci1;

使用哪一个：类似于 const int 与 int >：只要可以使用 const 迭代器（当您不需要用它们修改容器时），就更喜欢使用它们，以更好地记录您无需修改​​的阅读意图。

Answer 4

不幸的是，STL 容器的许多方法都采用迭代器而不是const_iterators作为参数。 因此，如果你有一个 const_iterator，你不能说“在这个迭代器指向的元素之前插入一个元素”（在我看来，这样的说法在概念上并不是违反 const 的）。 如果您无论如何都想这样做，则必须使用 std::advance() 或 boost::next() 将其转换为非常量迭代器。 例如。 boost::next(container.begin(), std::distance(container.begin(), the_const_iterator_we_want_to_unconst))。 如果容器是std::list，则该调用的运行时间将为O(n)。

因此，当涉及到 STL 容器时，在任何“合乎逻辑”的地方添加 const 的通用规则就不那么通用了。

然而，boost 容器采用 const_iterators（例如 boost::unordered_map::erase()）。 因此，当您使用 boost 容器时，您可以变得“非常激进”。 顺便问一下，有谁知道 STL 容器是否或何时会被修复？

Answer 5

尽可能使用const_iterator，当你别无选择时使用iterator。

Answer 6

（正如其他人所说） const_iterator 不允许您修改它指向的元素，这在 const 类方法内部很有用。 它还可以让您表达您的意图。

Answer 7

好吧，让我先用一个非常简单的例子来解释它，而不使用常量迭代器
考虑我们有随机整数集合“randomData”，

    for(vector<int>::iterator i = randomData.begin() ; i != randomData.end() ; ++i)*i = 0;
for(vector<int>::const_iterator i = randomData.begin() ; i!= randomData.end() ; ++i)cout << *i;

可以看出，在集合内写入/编辑数据时，使用了普通迭代器，但为了读取目的，使用了常量迭代器。 如果您尝试在第一个 for 循环中使用常量迭代器，您将收到错误。 作为经验法则，使用常量迭代器读取 collection 内的数据。