List of C/C++ inspections
Data flow analysis
|Constant conditions||Analyzes method control and data flow to report conditions that are always true or false and expressions with statically constant values.||Warning|
|Dangling pointers||Detects pointers that point to invalid data, typical cases are double-free and use-after-free problems. Check out this parent ticket for the list of limitations.||Warning|
Detects when a function produces infinite recursion.
|Local value escapes scope|
Detects variables that reference local values that escape their scope.
|Loop condition isn't updated inside the loop|
Detects situations where a loop condition is not updated inside the loop, which can cause an infinite loop.
There is a similar inspection in Clang-Tidy,
Reports when a non-void function doesn't have a
|Not initialized variable|
Detects the local variables that haven't been initialized before usage.
|Null dereferences||Detects dereferences of pointers that may contain the ||Warning|
|Unreachable code||Detects the code that is never executed (dead code).||Warning|
|Unused local variable||Detects the variables that are declared but not used and never accessed for reading.||Warning|
|Unused parameter||Detects the parameters that are declared but not used and never accessed for reading.||Warning|
Reports the cases when the value of a variable is never used after the assignment.
Clear the Warn about unused variable initializers checkbox to disable the inspection for default variable initializers (for example, if you prefer to assign
|Function implicit declaration|
Reports when a function is used prior to being declared.
|Hides upper scope|
Reports local variables declared in the scope of other local variables or parameters with the same name.
|Hiding non-virtual function|
Reports when a function hides non-virtual functions with the same signature from the base class.
|Not implemented functions|
Detects when a function is declared but not defined.
|Passing arguments to function with K&R unspecified parameters syntax|
Reports when a function with the K&R parameters syntax uses a non-empty argument list.
|Argument selection defects|
Compares the names of arguments in a call and formal parameter names in the declaration to detect the errors like accidental switching of the arguments.
See Inspection: Argument selection defects for details.
Performs various clang-tidy checks related to C++ Core Guidelines, code modernization, readability, and performance issues.
See Clang-Tidy integration for details.
|Unconstrained variable type|
Suggests constraining local variables declared as
This inspection is disabled by default on Windows and is not supported for concepts declared with the
|Duplicate switch case|
|Empty declaration or statement|
Reports the redundant empty declarations and statements that can be safely removed.
Detects when a call to a string format function (such as
|'=' in conditional expression|
Detects when the
Reports when a symbol violates the currently selected naming convention.
Find more details in Inspecting code for violations of the naming rules.
You can adjust the list of checks in the Options section.
Note that on Windows with MSVC (including the case of clang-cl ), CLion shows only the MISRA C++ checks. MISRA C checks can't be shown correctly because they apply to a specific language standard configurable via the
|Missing switch case|
Reports when a
|Resource not found|
Reports unresolved references to resources like NIBs, images, and others.
Suggests to simplify the following types of statements:
|Usage of deprecated API|
Detects the usages of deprecated code in the specified scope.
|Virtual call from constructor or destructor|
Reports when a virtual function is called from a constructor or destructor, helping to prevent situations when virtual functions access the resources that are not yet initialized or have already been destroyed.
|Implicit integer and enum conversion|
Detects when a num type expression is used in the context of an integer or pointer type, and vice versa.
|Implicit pointer and integer conversion|
Detects when an integer type expression is used in the context of a pointer type, and vice versa.
Reports the cases when an expression of the enum type A is used in the context of another enum type B (assigned, casted, used in a parameter, returned from a method, function or a block, and so on).
Reports the cases when a variable initializer doesn't match the declared type. For example, when there are too many initializers for an array or structure.
Reports when an expression of a pointer type A is used in the context of another pointer type B (assigned, casted, used in a parameter, returned from a method, function or a block, and so on).
This inspection doesn't check class type pointers.
Reports when an expression of type A is used in the context of type B, whereas A and B are class types, and B is not a superclass of A.
Reports unnecessary type cast expressions.
Reports when an expression of a signed type is used in the context of an unsigned type (assigned, casted, used in a parameter, returned from a method, function or a block, and so on).
|Value may not fit into receiver|
Reports when an expression of type A is used in the context of type B, while the range of values in type B is not large enough to store all possible values of type A.
Detects C++ concepts that are never used.
|Unused expression result|
Reports the expressions whose results are never used.
|Unused global declaration|
Detects when a global function or variable is declared but never accessed or written.
|Unused include directive|
Reports the unused or unrequired
See Inspection: Unused include directive for details.
Detects macro definitions that are never used in the code.
Detects C/C++ classes and structures that are never used.
|Unused template parameter|
Detects C++ class and function template parameters that are never used.