Why is this an issue?
C-style arrays (such as int i[10]) are not very convenient to use:
- They are fixed size (even C VLA are not truly variable size, and they are not supported in C++)
- If the number of elements in the array can vary, it will lead to manual memory allocation (or people will use fixed-size arrays that "should be
large enough", which is both a waste of memory and a limitation of the program)
- It is very easy to lose the size of the array since an array passed to a function decays into a pointer
The C++ standard library proposes two types that are better than C-style arrays and together cover all the use cases of C-style arrays:
- For fixed-size arrays, where the memory is on the stack, use
std::array. It is like a C-style array, except that it has a normal
argument passing semantic, and the size is always a part of the type. If std::array is not available to you (before C++11), you can
roll your own version.
- For variable-size arrays, use
std::vector. It can be resized and handles memory allocation transparently.
- For character strings, you should use
std::string instead of arrays of characters.
- For arrays of characters that are not strings (e.g., alphabet, exit codes, keyboard control list) perfer
std::array or
std::vector as per the first two bullets.
The rule {rule:cpp:S945} is related to this rule but focuses on passing arguments of an array type. {rule:cpp:S5025} will flag the use of dynamic
memory allocation that could be replaced by std::vector.
Noncompliant code example
void f() {
int a[10]; // Noncompliant
}
Compliant solution
void f() {
std::array<int, 10> a1; // If the size really is a constant
// Or
std::vector<int>a2; // For variable size
auto s = "Hello!"; // Compliant by exception
}
Exceptions
This rule will not report the use of C-style arrays in extern "C" code (since those arrays are often required here for compatibility
with external code) and in the arguments of main.
Resources
