Code Inspection and Quick-Fixes in C++
The key features of JetBrains Rider's code analysis are also supported in C++. You can find the detailed information on these features in the corresponding topics of the Code analysis section. In the main topic of the section, you can also find the feature matrix and check what exactly is supported in C++.
In this topic, you can find some examples of using code analysis features in C++.
By default, code inspection, quick-fixes, and context actions are available in all solution files. If necessary, you can enable these features in external files referenced from solution with the Enable inspections, quick fixes and context actions in files external to the solution checkbox on the page of JetBrains Rider settings Control+Alt+S.
JetBrains Rider's static code analysis detects most of compiler errors and some compiler warnings in C++ files.
Besides, it finds other code issues, which otherwise would be found in runtime. For example, using a virtual method in constructor leads to unexpected behavior as mentioned in this StackOverflow question. JetBrains Rider points at this problem before you even compile:
To find out what kind of code inspections JetBrains Rider provides, check out the full list of JetBrains Rider C++ code inspections.
For more information about the code inspection, refer to Configure code inspection settings.
To quickly turn off a particular inspection or suppress all the inspections, use the inspection context menu:
Quick-fixes let you automatically resolve most of code issues found with code inspection. If one or more quick-fixes are available for a code issue, you will see the corresponding action indicator when your caret is on the highlighted code. Press Alt+Enter to see and apply the desired fix.
JetBrains Rider provides over 290 quick-fixes for C++. Here are some examples:
Add missing #include directive
If you use a symbol that is defined in the standard libraries or elsewhere in your solution, JetBrains Rider helps you add the missing
#include directives automatically:
You can use the Show popups for import actions checkbox on the page of JetBrains Rider settings Control+Alt+S to disable the popup.
If the checkbox is not selected, the corresponding action will be available in the action list when you press Alt+Enter.
Add forward declaration
JetBrains Rider can also generate a forward declaration for an unresolved symbol:
[[maybe_unused]] attribute can be added to avoid warnings from the compiler about an unused name or entity. When the caret is on an unused entity, the following quick-fix will be available:
And another context action will help you to replace usages of
Q_UNUSED with a
Add to capture list
If a local variable is used inside a lambda body but not captured by this lambda, JetBrains Rider suggests quick-fixes to update the capture list. You can capture the variable or
this by value, by reference, or implicitly capture all the used automatic variables:
Change return type
If a function return type does not match the value it actually returns, JetBrains Rider lets you quickly fix the return type:
Change variable type
If the specified type of a variable or a field does not match to the assigned value, JetBrains Rider provides a quick-fix to use the correct type in the declaration:
If a member function in a C++ file does not have declaration in the header file, JetBrains Rider helps you create the missing declaration according to the signature of the implementation:
Create from usage
If you use an undeclared symbol, JetBrains Rider suggests one or more quick-fixes for creating the symbol based on the usage:
If JetBrains Rider detects uninitialized type members, it suggests initializing all members in one fix. You can also use the sub-menu of this fix to generate initializations for specific members.
JetBrains Rider detects uninitialized variables and helps initializing them with the default value:
Remove unused #include directives
#include are highlighted and can be easily removed with a quick-fix:
Remove unused lambda capture
If a local variable is captured by a lambda but not used inside the lambda body, JetBrains Rider notifies you and suggests removing the unused capture:
Replace the dot (.) with arrow (->) and vice versa
If the dot
. operator is erroneously applied to a pointer, JetBrains Rider helps you replace it with the arrow
The reverse quick-fix is also available:
Use explicit template parameters in lambda
JetBrains Rider detects when lambda can be rewritten to use the new C++20 template syntax:
If the parameter’s type is an rvalue reference, you may want to pass that type directly to
std::forward. In this case, you can use familiar perfect forwarding syntax:
JetBrains Rider detects cases when you should prefer
static_cast and helps you update your code:
Functional-style cast used instead of a C++ cast:
reinterpret_castused instead of a
static_castwhen casting to
Make JetBrains Rider ignore specific code
To exclude parts of your solution's code from code analysis, navigation, and other features, JetBrains Rider allows you to ignore specific files, folders and file masks in different ways.