Good Practice Defects

Defects that allow you to observe good coding practices such as detection of hard-coded memory buffer size or unused function parameters

These defects allow you to observe good coding practices. The defects by themselves might not cause a crash, but they sometimes highlight more serious logical errors in your code. The defects also make your code vulnerable to attacks and hard to maintain. The defects include:

Hard-coded constants such as buffer size and loop boundary
Issues that hinder code readability
Potential coding errors
Missing const

Polyspace Results

expand all

Code Readability Issues

`Ambiguous declaration syntax`	Declaration syntax can be interpreted as object declaration or part of function declaration
`Incorrectly indented statement`	Statement indentation incorrectly makes it appear as part of a block (Since R2020a)
`Invalid scientific notation format`	the use of an invalid format makes the code less readable (Since R2022b)
`Line with more than one statement`	Multiple statements on a line

Code Duplication

`Duplicated code`	A section of code is duplicated in other places (Since R2023a)
`Partially duplicated code`	A section of code is duplicated in other places with very minor changes (Since R2023a)

Hard-coded Constants

`Hard-coded buffer size`	Size of memory buffer is a numerical value instead of symbolic constant
`Hard-coded loop boundary`	Loop boundary is a numerical value instead of symbolic constant
`Hard-coded object size used to manipulate memory`	Memory manipulation with hard-coded size instead of `sizeof`

Missing Const

`Method not const`	A method that can be made `const` is not marked `const` (Since R2022a)
`Public static field not const`	A `static` and `public` field of a `struct` or `class` is not marked as a `const` (Since R2022a)
`Unmodified variable not const-qualified`	Variable not `const`-qualified but variable value not modified during lifetime (Since R2020a)

Macros Prone to Misuse

`Macro terminated with a semicolon`	Macro definition ends with a semicolon (Since R2020a)
`Macro with multiple statements`	Macro consists of multiple semicolon-terminated statements, enclosed in braces or not (Since R2020a)

Ill-Formulated Conditionals, Switches, and Loops

`Missing break of switch case`	`case` block of `switch` statement does not end in a `break`, `[[fallthrough]]` or explanatory comment
`Possibly inappropriate data type for switch expression`	`switch` expression has a data type other than char, short, int or enum (Since R2020a)
`Semicolon on same line as if, for or while statement`	Semicolon on same line results in empty body of `if`, `for` or `while` statement (Since R2020a)

Bad Memory Management

`Delete of void pointer`	`delete` operates on a `void*` pointer pointing to an object
`Missing overload of allocation or deallocation function`	Only one function in an allocation-deallocation function pair is overloaded
`Missing reset of a freed pointer`	Pointer `free` not followed by a reset statement to clear leftover data

C++ Best Practices Not Followed

`C++ reference to const-qualified type with subsequent modification`	Reference to `const`-qualified type is subsequently modified
`C++ reference type qualified with const or volatile`	Reference type declared with a redundant `const` or `volatile` qualifier
`Declaration of catch for generic exception`	A `catch` block handles a generic exception that might have many different subtypes (Since R2022a)
`Declaration of throw for generic exception`	A function throws a generic exception, which might have many subtypes (Since R2022a)
`Reference to un-named temporary`	Local reference is declared by using unnamed temporary variable that a function returns by value (Since R2023a)

Use of Forbidden or Deprecated Constructs

`Incorrect syntax of flexible array member size`	Flexible array member defined with size zero or one
`Use of a forbidden function`	Use of function that appears in a blocklist of forbidden functions (Since R2020a)
`Use of a forbidden keyword`	Use of keyword that appears in a blocklist of forbidden keywords (Since R2022a)
`Use of a forbidden macro`	Use of macro that appears in a blocklist of forbidden macros (Since R2022b)
`Use of setjmp/longjmp`	`setjmp` and `longjmp` cause deviation from normal control flow

Other

`Bitwise and arithmetic operation on the same data`	Statement with mixed bitwise and arithmetic operations
`File does not compile`	File has a compilation error (Since R2021a)
`Unused parameter`	Function prototype has parameters not read or written in function body
`Unused variable`	Variable defined or declared but not read or written (Since R2024a)
`Useless expressions in sizeof operand`	`sizeof` operand contains expression that is not evaluated (Since R2020a)
`Useless include`	An include directive is present but not used (Since R2022b)
`Useless capture`	Lambda captures objects but does not use the objects (Since R2024b)

Topics

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