AUTOSAR C++14 Rule A26-5-2

Random number engines shall not be default-initialized

Description

Rule Definition

Random number engines shall not be default-initialized.

Rationale

Pseudorandom number generators depend on an initial seed value to generate a sequence of random numbers. Default initialization of random number engines is done by using a default seed, which is a constant value. If you call a random number generator that has default initialization multiple times, you get the same sequence every time. To generate nonrepeating random number sequences, use unique, nondefault seed values each time that you initialize a random number generator.

This rule prevents the generation of deterministic sequences in production code where randomness is required. An exception to this rule is allowed when a deterministic sequence is required for consistent testing purposes.

Polyspace Implementation

The checker reports violations on the lines in which:

A C++ standard random number generator is default-initialized.
The seeding function of a random number generator is called by using an implicit call to default arguments or an explicit default_seed argument..

Note

The checker does not report random number engine initializations that have constant input arguments.

Troubleshooting

If you expect a rule violation but do not see it, refer to the documentation for Polyspace^® Bug Finder™ or Polyspace Bug Finder Server™.

Examples

expand all

Noncompliant Random Number Generator Initialization

The declaration of std::default_random_engine eng1 is noncompliant because it is constructed by using the default argument, the default_seed constant.

#include <iostream>
#include <random>

int main()
{
  std::default_random_engine eng1{};     //Noncompliant
  std::uniform_int_distribution<int> ud2{0, 100};
  std::random_device rd;
  std::default_random_engine eng2{rd()}; //Compliant
  std::default_random_engine eng3{rd()}; //Compliant
  eng3.seed();                           //Noncompliant   

return 0;
}

The second declaration std::default_random_engine eng2 is compliant because it takes a user-defined random_device object as its initialization argument.

The declaration of std::default_random_engine eng3 is also compliant. eng3.seed() is noncompliant because the seeding function std::default_random_engine seed uses the default_seed constant as an argument, which overwrites the seed of eng3 that is correctly initialized.

Check Information

Group: Algorithms library

Category: Required, Automated

Introduced in R2020b

Documentation