Main Content

Performance Defects

Defects that impact performance of C++ code

These defects detect issues that can lead to performance bottlenecks in C++ code. The detected issues include:

  • Issues that inadvertently cause copy instead of move operations

  • Inefficient or unnecessary temporary variable creation

  • Use of a function that has a possibly more efficient alternative

Polyspace Results

expand all

A move operation may throwThrowing move operations might result in STL containers using the corresponding copy operations (Since R2020b)
Const parameter values may cause unnecessary data copiesConst parameter values may prevent a move operation resulting in a more performance-intensive copy operation (Since R2020a)
Const return values may cause unnecessary data copiesConst return values may prevent a move operation resulting in a more performance-intensive copy operation (Since R2020a)
Const rvalue reference parameter may cause unnecessary data copiesThe const-ness of an rvalue reference prevents intended move operation (Since R2021a)
Const std::move input may cause a more expensive object copyConst std::move input cannot be moved and results in more expensive copy operation (Since R2020b)
Empty destructors may cause unnecessary data copiesUser-declared empty destructors prevent autogeneration of move constructors and move assignment operators (Since R2020a)
Expensive return of a const objectThe return statement of a function copies an objects instead of moving it because the returned object is declared as a const (Since R2022a)
Move operation uses copyNon-const rvalue reference parameter of a function or operator is copied instead of moved (Since R2021b)
std::move called on an unmovable typestd::move used on a class type with no move constructor or move assignment operator (Since R2020b)
Expensive copy in a range-based for loop iterationThe loop variable of a range-based for loop is copied from the range elements instead of being referenced resulting in inefficient code (Since R2020b)
Expensive local variable copyLocal variable is created by copy from a const reference and not modified later (Since R2021a)
Expensive member initializationYou assign values to class members in the constructor body instead of constructing members using a member initializer list (Since R2023b)
Expensive pass by valueParameter might be expensive to copy (Since R2020b)
Expensive return by valueFunctions return large output by value instead of by reference or pointer (Since R2020b)
Expensive use of std::any_castAn object is cast by-value using std::any_cast when casting by-reference is more efficient (Since R2023b)
Expensive construction of std::string or std::regex from constant stringA constant std::string or std::regex object is constructed from constant data, resulting in inefficient code (Since R2020b)
Missing constexpr specifierconstexpr specifier can be used on variable or function for compile-time evaluation (Since R2020b)
Unnecessary construction before reassignmentInstead of directly constructing objects with value, you construct objects and then immediately assign values to objects (Since R2023a)
Expensive unused objectExpensive local object is constructed but not used (Since R2024a)
Expensive std::function type definitionDefinition of std::function type uses pass-by-value semantics for arguments that are expensive to copy (Since R2024a)
Expensive dynamic castExpensive dynamic_cast is used instead of more efficient static_cast or const_cast (Since R2021b)
Expensive use of a standard algorithm when a more efficient method existsFunctions from the algorithm library are misused with inappropriate inputs, resulting in inefficient code (Since R2021b)
Expensive use of non-member std::string operator+() instead of a simple appendThe non-member std::string operator+() function is called when the append (or +=) method would have been more efficient (Since R2020b)
Expensive use of std::string methods instead of more efficient overloadAn std::string method is called with a string literal of known length, instead of a single quoted character (Since R2021a)
Expensive use of std::string with empty string literalUse of std::string with empty string literal can be replaced by less expensive calls to std::basic_string member functions (Since R2021a)
Expensive use of string functions from the C standard libraryString functions from the C standard library are used inefficiently (Since R2022a)
Expensive use of substr() to shorten a std::stringThe method std::string::substr() is called to shorten an std::string object (Since R2022a)
Inefficient use of sprintfThe function sprintf, snprintf, or swprintf copies strings instead of the more efficient strcpy, strncopy, or wcsncpy (Since R2021b)
Inefficient string length computationString length calculated by using string length functions on return from std::basic_string::c_str() instead of using std::basic_string::length() (Since R2020a)
std::endl may cause an unnecessary flushstd::endl is used instead of the more efficient \n (Since R2020a)
Use of new or make_unique instead of more efficient make_sharedUsing new or make_unique to initialize or reset shared_ptr results in additional memory allocation (Since R2021a)
Unnecessary use of std::string::c_str() or equivalent string methodsInstead of a std::string object, a string operation uses the C-string obtained from std::string functions including std::string::c_str, std::string::data(), std::string::at(), or std::string::operator[], resulting in inefficient code (Since R2020b)
Expensive use of container's count methodThe function member count() of a container is used for checking if a key is present, leading to inefficient code (Since R2021b)
Expensive use of container's insertion methodsOne of the insertion methods of a container is used to insert a temporary object (Since R2022a)
Expensive use of container's size methodA container's size() method is used for checking emptiness instead of its empty() method, which is more efficient (Since R2022b)
Expensive use of map's bracket operator to insert or assign a valueThe bracket operator of std::map or std::unordered_map is used for inserting or assigning a value in the container instead of the insert_or_assign() method, which is more efficient (Since R2022b)
Missing call to container's reserve methodA fixed number of items are added to a container without calling the reserve() method of the container beforehand, resulting in inefficient code (Since R2022b)
Expensive use of map instead of setThe key for a map is member of the object being inserted, resulting in redundant map key (Since R2024b)
Expensive logical operationA logical operation requires the evaluation of both operands because of their order, resulting in inefficient code (Since R2021a)
Expensive return caused by unnecessary std::moveAn unnecessary call to std::move in the return statement hinders return value optimization, resulting in inefficient code (Since R2022b)
Expensive allocation in loopFixed sized memory is allocated or deallocated in a loop (Since R2022a)
Expensive post-increment operationObject is post-incremented when pre-incrementing is faster (Since R2021b)
Inefficient use of for loopRange-based for loop can perform equivalent iteration more efficiently (Since R2022a)
Unnecessary PaddingMembers of a struct are padded to fulfill alignment requirement when rearranging the members to fulfill this requirement saves memory (Since R2021b)
Unnecessary implementation of a special member functionImplementing special member functions hinders code optimization when implicit versions are equivalent (Since R2023a)
Unnecessary reference to parameterParameter is passed to function as const reference when passing by value is more efficient (Since R2024a)

Topics

  • Bug Finder Defect Groups

    The Bug Finder defect checkers are classified into groups such as data flow, concurrency, numerical, and so on.