Missing constexpr specifier

constexpr specifier can be used on variable or function for compile-time evaluation

Description

This defect identifies potential constexpr variables and functions. For instance, the defect occurs if:

• You omit the constexpr specifier when a variable is initialized by using an expression that can be evaluated at compile time.

  The defect checker flags a local variable definition without the constexpr specifier if the variable is initialized with one of the following and not modified subsequently in the code:

  • An expression involving compile-time constants only.

  • Calls to a function with compile-time constants as parameters, provided the function is itself constexpr or the function contains only a return statement involving its parameters.

  • A constructor call with a compile-time constant, provided all member functions of the class including the constructor are themselves constexpr.

  The checker does not flag local, static variables.

• You omit the constexpr specifier from functions with a single return statement that could potentially be evaluated at compile time (given compile-time constants as arguments).

Risk

If a variable value is computed from an expression that involves compile-time constants only, using constexpr before the variable definition, like this:

constexpr double eValSquared = 2.718*2.718;

ensures that the expression is evaluated at compile time. The compile-time evaluation saves on run-time overheads. Sometimes, the performance gains at run time can be significant.

If the expression cannot be evaluated at compile time, the constexpr keyword ensures that you get a compilation error. You can then fix the underlying issue if possible.

Note that the const keyword does not guarantee compile-time evaluation. The const keyword simply forbids direct modification of the variable value after initialization. Depending on how the variable is initialized, the initialization can happen at compile time or run time.

Fix

Add the constexpr specifier to the variable or function definition.

Performance improvements might vary based on the compiler, library implementation, and environment that you are using.

Note that constexpr functions are implicitly inlined. So, if you add a constexpr qualifier to a function definition and the function is referenced in multiple source files, you see a compilation error. In this case, move the function definition to a header file that is included in the sources from which the function is called.

Examples

Potential constexpr Variables and Functions

        double squareIfPositive(double val) {
    return val > 0? (val * val): 0;
}

void initialize(void) {
    double eVal = 2.718;
    double eValSquare = squareIfPositive(2.718);
}

In this example, the checker flags the definition of squareIfPositive because the function contains a single return statement involving only its parameter val. Therefore, if val is a compile-time constant, the function can be evaluated at compile-time and can be a constexpr function.

The checker also flags the definition of eValSquare because it is initialized with a potentially constexpr function that takes a compile-time constant as argument.

Correction – Add constexpr Specifier

Add constexpr specifiers to the variable and function definitions.

          
constexpr double squareIfPositive(double val) {
    return val > 0? (val * val): 0;
}

void initialize(void) {
    constexpr double eVal = 2.718;
    constexpr double eValSquare = squareIfPositive(2.718);
}

Result Information

Group: Performance

Language: C++

Default: Off

Command-Line Syntax: MISSING_CONSTEXPR

Impact: Medium

PQL Name: std.defects.MISSING_CONSTEXPR

Version History

Introduced in R2020b

R2026a: Checker identifies constexpr objects more precisely

Polyspace^® now checks for constexp objects in your code more precisely:

• Polyspace now recognizes that std::vector::size() is a constexpr function and does not report this defect on it. For example, no violations are reported on this code:

  void truc(std::vector<int>& vi) {
      for(size_t i= 0, size = vi.size(); i < size; ++i) {
      }
    }

• Polyspace no longer reports violations on method chains unless every method called in the chain can be declared as constexpr. For example:

  struct S {
      constexpr S& foo() { return *this; }
      S& bar() { return *this; }
  };
  
  S test;
  
  void t() {            
      test.foo().bar();    
  }
  

  A method chain containing a non-constexpr method cannot be declared constexpr.

R2025a: Checker no longer flags variables defined from members of const objects or variables created from template instantiations

The checker no longer incorrectly flags:

• Variables defined using members of const objects as potential candidates for constexpr qualification, for instance:

  #include <optional>
  #include <string>
  
  struct S {
      std::optional<std::string> maybe;
  };
  
  void bug(const S& x) {
      const auto&  r = *x.maybe; // 'r' cannot be constexpr
  }

• Variables defined from instantiation of a template that cannot be instantiated at compile time, for instance, the variable end here:

  template <typename Buffer, typename Number>
  static char const *safeToString(Buffer &buffer, Number const &num)
  {
    auto const end{buffer.data() + buffer.size()};
  }
  void func() {
    std::array<char,5> as_an_array{};
    safeToString(as_an_array,2);
    std::string as_a_string{"Something"};
    safeToString(as_a_string,2);
  }
  

R2024b: Checker identifies potential constexpr objects more accurately

The defect checker no longer reports this defect in these cases:

• Variables of nonliteral types.

• Functions that declare one or more static variables in their body.

• Functions that declare one or more thread-local variables.

• Functions that declare non-static and non-thread-local local variables but do not initialize them.

• Variables that store values that cannot be calculated at compile time, such as the current time or the status of a file or directory.

• Constructors when the constructor's arguments call a member function on an object passed to the constructor. These calls can depend on runtime values.

• Code that uses chained member access.

• Lambda objects.

R2024a: Checker identifies inner block constexpr objects

The checker now flags instances of potential constexpr variables and functions inside nested code blocks. For example:

constexpr double squareIfPositive(double val) {
    return val > 0 ? (val * val) : 0;
}

void initialize(void)
{
	while (true) {
		double j = squareIfPositive(2.718);           // Noncompliant
	}
}

R2023a: Checker identifies potential constexpr objects more accurately

The defect checker:

• No longer does a mass reporting of variables initialized with constexpr constructors as potential constexpr objects. The checker now takes the constructor arguments into account. For instance, if the constructors take arguments that can be evaluated only at run time, variables initialized with those constructors are not appropriate for constexpr-qualification.

• Does not report a pointer to a buffer a potential constexpr object if the buffer is assigned to another pointer and the buffer is written via the second pointer.

R2021b: Checker shows fewer false positives

The checker:

• No longer flags variables initialized with literal values as potential constexpr variables (since there might be no performance gain in declaring them constexpr).

• Flags functions that contain only a return statement involving the function parameters as potential constexpr functions.