CERT C++: CTR55-CPP

This issue occurs when:

Such operations might result in an iterator before the begin iterator or after the end iterator of a container. For instance:

void print_vec(const std::vector<int> &v) {
	auto end_it = v.begin()+20;//Noncompliant
	for (auto it = v.begin(); it != end_it; ++it) {
		//...
	}
}

Polyspace raises this violation for sequence containers such as std::vector, std::array, and std::deque. As an exception, Polyspace does not report a violation if iterators are incremented or decremented by using the pre or post increment or decrement operators.

The C++ standard does not guarantee the dereferencibility of iterators that are beyond the bounds of the container. An addition or subtraction operation that results in a possible iterator overflow cause an undefined behavior. Often, such an iterator overflow leads to a buffer overflow or buffer underrun. These defects might be exploited by an attacker to execute malicious code.

Validate the addition and subtraction operations on iterators so that the resultant iterators do not overflow.

#include<vector>
#include<string>
#include<iostream>
//Template function that accepts any container and prints the first 20 values
template<typename C, typename T = typename C::value_type>
void checkFirst20(C const& container)
{
  
  for(auto it = container.begin(), last = it+20; it!=last;++it)//Noncompliant
  {std::cout<<*it<<'\n';}
}

void foo(){
	std::vector<float> v(20);
	checkFirst20(v);
}

In this example, the function checkFirst20() calculates the value of the iterator last adding 20 to another iterator it. The code does not verify if last remains within the bounds of container. Dereferencing such an iterator might result in undefined behavior. Polyspace reports a violation of this rule on this addition.

To fix this issue, validate the addition operation that defines last so that the iterator does not point beyond the bounds of container. For instance, in the addition operation that defines last, use the smaller of 20 and the value container.size() so that last is within the bounds of container.

#include<vector>
#include<string>
#include<iostream>
//Template function that accepts any container and prints the first 20 values
template<typename C, typename T = typename C::value_type>
void printFirst20(C const& container)
{
 typename C::size_type max = 20;
  for(auto it = container.begin(), 
      last = it + std::min(max,container.size());
       it!=last;++it)//Compliant
  {std::cout<<*it<<'\n';}
}

void foo(){
	std::vector<float> v(5);
	printFirst20(v);
}