List of C/C++ inspections

Analyzes method control and data flow to report conditions that are always true or false and expressions with statically constant values.

Detects functions whose return value is always equal to the same constant.

Detects functions where a parameter is always equal to the same constant.

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.

Detects the for, while, and goto statements that can break only by throwing an exception.

Detects when a function produces infinite recursion.

Detects variables that reference local values that escape their scope.

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, clang-tidy:bugprone-infinite-loop. However, it doesn’t cover loops with exit points and throws up false positives in cases with lambdas or references. This check is disabled in CLion's default Clang-Tidy profile.

Reports when a non-void function doesn't have a return statement, or when it can exit bypassing it.

Detects the local variables that haven't been initialized before usage.

Detects dereferences of pointers that may contain the nullptr.

Detects functions whose call sites are never executed.

Detects the code that is never executed (dead code).

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 nullptr to the variables of pointer type).

Reports when a function is used prior to being declared.

Reports local variables declared in the scope of other local variables or parameters with the same name.

Reports when a function hides non-virtual functions with the same signature from the base class.

Detects when a function is declared but not defined.

Reports when a function with the K&R parameters syntax uses a non-empty argument list.

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.

Performs Qt-related clazy checks.

Reports duplicated case expressions and overlapping case ranges in switch statements.

Reports the redundant empty declarations and statements that can be safely removed.

Detects when a call to a string format function (such as NSLog or printf) has inconsistent format specifier, wrong argument type, or incorrect number of arguments.

Detects when the = operator is used in conditional expressions where there should be ==.

Reports when a symbol violates the currently selected naming convention.

Find more details in Inspecting code for violations of the naming rules.

Performs the checks defined by the MISRA C 2012 and MISRA C++ 2008 guidelines. See the list of currently supported checks.

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 -std=cXY flag, which is not supported by MSVC.

Reports when a switch statement don't include all of the enumerated type's elements as cases. It also reports switch statements over an integer type that don't include a default: branch.

Finds cases where a preprocessor #endif comment doesn’t match the macro name.

Reports unresolved references to resources like NIBs, images, and others.

Suggests to simplify the following types of statements:

• condition == true
• condition1? true : condition2
• if(condition1) return true; return condition2;

• statements for identical branches

• if(true) or while(false)

Suggests constraining local variables declared as auto if the result of a constrained expression or function call is assigned to them.

This inspection is disabled by default on Windows and is not supported for concepts declared with the requires clause syntax.

Detects the usages of deprecated code in the specified scope.

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.

Detects when a num type expression is used in the context of an integer or pointer type, and vice versa.

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).

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.

Reports the expressions whose results are never used.

Detects when a global function or variable is declared but never accessed or written.

Reports the unused or unrequired include directives, which can be safely removed.

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.

Detects C++ class and function template parameters that are never used.