AutosarC++17_03-A5.2.5¶
An array or container shall not be accessed beyond its range
Required inputs: IR, StaticSemanticAnalysis
| Level | required |
|---|---|
| Target | implementation |
| Enforcement | automated |
Rationale
To avoid undefined behavior, range checks should be coded to ensure that the array access via pointer arithmetic or subscript operator is within defined bounds.
This could be also achieved by accessing an array via subscript operator with constant indexes only.
Note that this rule applies to C-style arrays and all other containers that access their elements using input index without range-checks.
Also, note that calculating an address one past the last element of the array is well defined, but dereferencing it is not.
Example
// $Id: A5-2-5.cpp 271752 2017-03-23 12:07:07Z piotr.tanski $
#include <array>
#include <cstdint>
#include <iostream>
void fn1() noexcept {
constexpr std::int32_t arraySize = 16;
std::int32_t array[arraySize]{0};
std::int32_t elem1 =
array[0]; // Compliant - access with constant literal that
// is less than ArraySize
std::int32_t elem2 =
array[12]; // Compliant - access with constant literal that
// is less than ArraySize
for (std::int32_t idx = 0; idx < 20; ++idx) {
std::int32_t elem3 = array[idx]; // Non-compliant - access beyond ArraySize
// bounds, which has 16 elements
}
std::int32_t shift = 25;
std::int32_t elem4 =
*(array + shift); // Non-compliant - access beyond ArraySize bounds
std::int32_t index = 0;
std::cin >> index;
std::int32_t elem5 =
array[index]; // Non-compliant - index may exceed the ArraySize bounds
if (index < arraySize) {
std::int32_t elem6 = array[index]; // Compliant - range check coded
}
}
void fn2() noexcept {
constexpr std::int32_t arraySize = 32;
std::array<std::int32_t, arraySize> array;
array.fill(0);
std::int32_t elem1 =
array[10]; // Compliant - access with constant literal that
// is less than ArraySize
std::int32_t index = 40;
std::int32_t elem2 =
array[index]; // Non-compliant - access beyond ArraySize bounds
try {
std::int32_t elem3 = array.at(50); // Compliant - at() method provides a
// range check, throwing an exception if
// input exceeds the bounds
} catch (std::out_of_range &) {
// Handle an error
}
for (auto &&e : array) // The std::array provides a possibility to iterate
// over its elements with range-based loop
{
// Iterate over all elements
}
}
See Also
- HIC++ v4.0 [8]: 5.2.1 Ensure that pointer or array access is demonstrably within bounds of a valid object.
Possible Messages
Key |
Text |
Severity |
Disabled |
|---|---|---|---|
arithmetic_out_of_bounds |
Pointer arithmetic on {node0} might create pointer outside array bounds of {name0} |
None |
False |
out_of_bounds |
Access into array is out of bounds |
None |
False |
possible_indirect_out_of_bounds |
Pointer-indirect access through {node0} might be out of bounds accessing {name0} |
None |
False |
possible_out_of_bounds |
Access into array might be out of bounds |
None |
False |
undereferenced_arithmetic_out_of_bounds |
Pointer arithmetic on {node0} might create pointer one past the end of {name0} (but not dereferenced) |
None |
False |
undereferenced_out_of_bounds |
Access is one past the end of the array (but not dereferenced) |
None |
False |
undereferenced_possible_indirect_out_of_bounds |
Pointer-indirect access through {node0} might be one past the end accessing {name0} (but not dereferenced) |
None |
False |
undereferenced_possible_out_of_bounds |
Access might be one past the end of the array (but not dereferenced) |
None |
False |
Options¶
This rule shares the following common options: confidence, exclude_in_macros, exclude_messages_in_system_headers, excludes, extend_exclude_to_macro_invocations, includes, justification_checker, languages, post_processing, provider, report_at, severity
The following places define options that affect this rule: Stylechecks, Analysis-GlobalOptions
abstract_interpretation_out_of_bounds¶
abstract_interpretation_out_of_bounds : bool = False
exclude_very_high_indices¶
exclude_very_high_indices : bool = True
report_unbounded_arrays¶
report_unbounded_arrays : bool = False
extern char buf[];.
report_undereferenced_one_past_the_end¶
report_undereferenced_one_past_the_end : bool = False
report_unknown_index¶
report_unknown_index : bool = False