AUTOSAR C++14 Rule A23-0-1

An iterator shall not be implicitly converted to const_iterator

Description

Rule Definition

An iterator shall not be implicitly converted to const_iterator.

Rationale

The C++11 standard introduces member functions such as cbegin and cend that returns const iterators to containers. To create const iterators, use these member functions instead of functions such as begin and end that return non-const iterators and then require implicit conversions.

For instance, consider the std::list container:

std::list<int> aList = {0, 0, 1, 2};

You can use the begin and end member functions of the container to create const iterators, for instance in a for loop:

for(std::vector<int>::const_iterator iter{aList.begin()}, end{aList.end()};
    iter != end;
    ++iter) {...}

However, the functions begin and end return non-const iterators and for assignment to the const iterators iter and end respectively, an implicit conversion must happen. Instead, take advantage of the new C++11 functions cbegin and cend that directly returns const iterators:

for(std::vector<int>::const_iterator iter{aList.cbegin()}, end{aList.cend()};
    iter != end;
    ++iter) {...}

If you use these functions, you can also replace the explicit type specification of the iterators with auto:

for(auto iter{aList.cbegin()}, end{aList.cend()};
    iter != end;
    ++iter) {...}

Polyspace Implementation

The checker flags conversions from type iterator to const_iterator or reverse_iterator to const_reverse_iterator.

Troubleshooting

If you expect a rule violation but do not see it, refer to Coding Standard Violations Not Displayed.

Examples

Implicit Conversions to Const Iterators

#include <cstdint>
#include <vector>

void func(std::vector<int32_t> & values, int32_t aValue) {
    std::vector<int32_t>::const_iterator iter1 = 
                  std::find(values.begin(), values.end(), aValue); //Noncompliant
    std::vector<int32_t>::const_iterator iter2 = 
                  std::find(values.cbegin(), values.cend(), aValue);  //Compliant
}

In this example, the first std::find function call uses as arguments the return values of the begin and end methods of an std::vector container values. These methods return iterators of type std::vector<intr32_t>::iterator. Since the std::find template has the same return type as the types of the first two arguments, it also returns an iterator of type std::vector<intr32_t>::iterator. The return value is assigned to a variable of type std::vector<intr32_t>::const_iterator, resulting in an implicit conversion.

The second call uses the cbegin and cend methods which return iterators of type std::vector<intr32_t>::const_iterator and avoid the implicit conversion.

Check Information

Group: Language support library

Category: Required, Automated