What′s New in ReSharper C++

ReSharper C++ 2019.3 nails every aspect of the editor, from code analysis and Clang-Tidy integration to navigation and code formatting. Make your code more readable with new type hints, and more compliant with the upcoming C++20 standard thanks to added support for several new features including Concepts. For game developers working with Unreal Engine 4 projects, v2019.3 delivers more templates to generate UE4-specific code and support for UE4’s Smart Pointers.

Free 30-day trial

ReSharper C++ 2019.3

C++20 support

C++20 support

C++20 is feature-complete and will be officially signed off next year to provide C++ developers with a range of long-awaited goodies. ReSharper C++ 2019.3 already supports many of these features, augmenting them with additional analysis and insights.

First, ReSharper C++ is now aware that aggregates can be initialized from a parenthesized list of values, and that an extra ADL needs to be performed in some cases with function templates.

Not only are concepts supported in ReSharper C++’s parser, but Rename refactoring and Find Usages are also available. Even better, code analysis can show you more details about errors related to Concepts. For example, if the overload resolution fails because a Concept’s requirement is not satisfied, you’ll see all the details in a tooltip. By the way, in ReSharper 2019.3 we’ve also added color to the tooltip that shows the details on the overloading resolution failures.

We’ve started a series of C++20 and ReSharper C++ blog posts, which you can use to learn about the new language features and their adoption in ReSharper C++.

Code analysis & quick-fixes

Code analysis & quick-fixes

If you find a Clang warning too distracting, you can now disable it from the inspection menu. And for all code checks, you can now suppress the corresponding inspection for all such issues in the file – simply use Disable in file with comment, or even suppress all inspections in the file with Disable all inspections in file with comment.

As you type a lambda body, a new quick-fix will assist you with adding variables to the lambda capture list. No need to do it manually – just place the caret on a variable in the lambda body and press Alt+Enter. ReSharper C++ will suggest a list of options for how to update the capture list.



In this version, we’ve upgraded the built-in Clang-Tidy binary to Clang 9, to give you many new code checks and accompanying fixes. Importantly, the bundled binary no longer prevents modifications to the source files. Clang-Tidy also starts more quickly as it doesn’t wait for all other ReSharper C++ analyses to finish.

Clang-Tidy settings were improved in a couple of areas:

  • You now have 3 options to select from for the Clang-Tidy executable to use in ReSharper C++. In addition to the bundled binary and a custom binary, which you can provide in settings, you can now select the one from %PATH% (ReSharper C++ will search in folders listed in the %PATH% environment variable and let you know if it finds anything).
  • You can now point ReSharper C++ to a specific Clang-Tidy configuration file instead of the YAML/JSON format string used before.

Type hints

ReSharper C++ gives you hints about your code to help improve its readability. New code hints added in v2019.3 help you identify types that might not be obvious when you look at modern C++ code:

  • For auto variables
  • In structured bindings
  • For function and lambda return types
Live templates

Live templates

In ReSharper C++ 2019.3, several live templates were renamed to match the corresponding language keyword. For example, to generate a class, type class (was cls before); for structures, use struct instead of str; and use similar logic for unions, enums and namespaces.

Navigation improvements

Navigation improvements

Go to file member was improved in two ways:

  • The dialog is shown instantly without waiting for the file to be parsed.
  • If the declaration and the definition of the function are both located in the same file, the dialog now lists them only once.

In initializer lists, code hints help you better understand what you are actually initializing. Now, you can also navigate to the aggregate class from the opening brace of a brace-enclosed initializer list.



In ReSharper C++ 2019.3, it’s now possible to export your formatting settings to a .clang-format file. Use ReSharper | Options | Code Editing | General Formatter Style | Write current style to .clang-format.

Two new formatter options were added to control the spacing:

  • before ptr in abstract declaration
  • before ref in abstract declaration

ReSharper C++ 2019.3 can now check the order of the #includes directives in your code. Simply provide the ordering settings, and a corresponding inspection and a quick-fix will help you notice if they’re out of order and reorder them in no time.

Unreal Engine 4 support

Unreal Engine 4 support

When ReSharper C++ detects you are developing an Unreal Engine project, it adjusts its behavior to be more UE4-specific.

The “new” postfix template for UCLASSes expands to a proper factory function call (which will register the created object in the garbage collector). Live templates with the corresponding names are now available to help you quickly generate USTRUCT/UCLASS/UENUM/UENUMCLASS.

Unreal Engine’s Smart Pointers (TSharedPtr, TSharedRef, TWeakPtr, TUniquePtr) are now handled by ReSharper C++ similarly to std::shared_ptr/std::unique_ptr. This means features like Parameter Info, code analysis, and postfix code completion work for Smart Pointers.

Finally, there are some performance improvements for UE4 projects. For example, we fixed a hang after "Refresh Visual Studio Project" in the UE4 editor.

Project Properties

Project Properties

For custom compiler toolchain or custom build tool cases, ReSharper C++ 2019.3 adds ReSharper Project Properties. They are stored in the ReSharper settings and allow you to specify:

  • Include directories
  • Preprocessor definitions
  • The C++ language standard

ReSharper C++ 2019.3 can now check the order of the #includes directives in your code. Simply provide the ordering settings, and a corresponding inspection and a quick-fix will help you notice if they’re out of order and reorder them in no time.

Performance improvements

Thanks to some improvements in the code highlighting engine, re-highlighting now happens faster. After a function’s body is changed, only the body will be reanalyzed.

Find Usages was sped up by adding a heuristic based on the graph of includes. This helps by cutting out the files without any usages.

Other changes

There are more changes coming from ReSharper. You can learn about them here.

Free 30-day trial

ReSharper C++ 2019.2

Faster startup times

In this release, we have finalized what we have been working on over the last few release cycles, and can now officially announce there is a new preprocessor implementation used inside ReSharper C++. There are two of them now, in fact – a newer one used for indexing, and an older one used for everything else. This new one delivers 15-25% faster indexing on typical solutions, like LLVM and Unreal Engine.

Completion summary tooltip

Code completion

In code completion, ReSharper C++ shows a summary tooltip for each item in the completion list (controlled by the Show summary checkbox in the Environment | IntelliSense | Completion Appearance page of the ReSharper options). The description for the selected completion item is now colored and shows the documentation for the corresponding item.

Code hints

Code hints

The editor has even more code hints to help improve code readability. New hints were introduced after preprocessor directives and for function arguments that are passed by a non-const reference, while hints in aggregate initialization expressions now show the names of the initialized base classes.

More C++20 support

The C++20 standard is almost ready to be signed off on by the C++ committee. And naturally, we are working hard to get fully compliant support in. ReSharper C++ 2019.2 got support for:

  • conditional explicit,
  • new char8_t type,
  • pack expansion in lambda init-capture,
  • default constructible and assignable stateless lambdas,
  • C++20 rules for aggregates,
  • consteval and constinit specifiers,
  • C++20 improvements to structured binding declarations.
Typing assist

Typing assist

Typing assist in multiline comments was improved. First of all, multiline comments that use single-line syntax are automatically extended. Second, extending multiline comments now inserts correct indentation when virtual space is enabled.

Wrapping code blocks with braces is now even easier – just select a block of code or an expression and then type an opening brace. ReSharper C++ will do the rest for you:



There are a whole bunch of new formatter options inside ReSharper C++ 2019.2:

  • Use continuous line indent in function declaration and invocation parentheses.
  • Prefer wrap before ")" in declaration.
  • Prefer wrap before ")" in invocation.
  • Use continuous line indent in initializer lists.
  • Align initializer list arguments.
  • Prefer wrap after "{" in initializer lists.
  • Prefer wrap before "{" in initializer lists.

Code analysis

New inspections are available to help you catch more code smells:

  • Unmatched preprocessor directive.
  • Explicitly defaulted special member function is implicitly deleted.
  • Redundant final function specifier in a final class.

The Use static_cast fix for the C-style cast used inspection can be run in bulk and as part of Code Cleanup.



Code navigation actions got an accuracy-targeted update:

  • Go to declaration can navigate to the default constructor called when an object is default-initialized in variable declarations and new expressions.
  • Find usages finds usages of default constructors in default initialization.
  • Go to symbol now hides symbols with qualified names (like, for example, out-of-class function definitions).

Besides, you can search in a file right through the Go to File member dialog. The result list will have names of all matched members, and all the places where the search string appears in the file.

Unreal Engine

In the previous release, we began to work towards better support for UE4-specific Remote Procedure Calls. Now, we've updated the Rename and Change Signature refactorings to work correctly on RPC functions. A few new code analysis checks are also available for UE4-based code, especially targeting the missing or incorrectly set UE4 reflection macros.

Following on from adding code completion for reflection specifiers in v2019.1, we've now added built-in documentation for them. It is shown in the Quick Documentation popup (Ctrl+Q) when the caret is located on a specifier.

Other features

ReSharper C++ 2019.2 provides initial support for the “Per-Monitor DPI Awareness” mode introduced in Visual Studio 2019. We’ve also updated the ReSharper | Options | Environment | Performance Guide page, adding a Windows Defender section as well as descriptions for all performance tips explaining what exactly will be done after a suggestion is applied.

There's some good news for plugin writers, too: C++ assemblies from ReSharper C++ are now included in the ReSharper SDK!

ReSharper C++ 2019.1

Performance improvements

ReSharper C++ 2019.1 introduces many performance improvements to speed up indexing and reduce memory usage. Both warm opening of large solutions and cold startup times have been improved. The memory usage optimizations include lower memory traffic during initial indexing, and a smaller memory footprint afterwards, which both help to enhance the editor responsiveness. Several performance improvements to code navigation and code completion are also inside.

In addition to memory optimizations, algorithmic improvements in code indexing, and faster cache serialization, we’ve added some special tuning for Unreal Engine projects. This includes skipping plugins and third-party code by default when indexing an Unreal Engine 4 project. The options that affect code indexing in Unreal Engine 4 solutions are grouped under a new options page at ReSharper | Options | Code Editing | C++ | Unreal Engine.

UE4 naming convention

Unreal Engine support

Unreal Engine naming convention

Naming rules help keep code readable. It may come as no surprise then that Epic Games has published the Unreal Engine 4 coding style guide, with a large section dedicated to their naming convention. Their general recommendation is to follow this guide when developing games with Unreal Engine. ReSharper C++ 2019.1 accommodates this naming convention across all its actions, including Introduce Variable and Rename refactorings, code generation for getters and setters, and many others.

ReSharper C++ also keeps an eye on the names you use across your code base. It highlights any inconsistencies with the UE4 naming convention by running Inconsistent UE4 naming inspections. Apply the corresponding quick-fix to trigger a full Rename refactoring for such a symbol.

UE4 reflection specifiers completion

Completion for reflection specifiers

To help you easily work with Unreal Engine reflection macros, ReSharper C++ offers completion for reflection specifiers inside reflection macros:

RPC navigation

Working with Remote Procedure Calls

ReSharper C++ 2019.1 will identify RPCs by Client, Server, or NetMulticast keywords in the UFUNCTION declaration statement. For such functions, ReSharper C++ is aware that an _Implementation function should be generated, as well as a _Validate function if WithValidation is set. It can generate both if both are missing, or only one if only one is missing.

When navigating to a definition, both functions (_Validate and _Implementation) will be suggested. Alternatively, these options are available in the Alt+Enter menu too, as “Related UE4 functions”. Learn more.

UE4 generated header checks

Auto-import respects the generated headers

When you use a symbol that’s not available in the current scope, ReSharper C++ highlights it in red and suggests adding the missing #include when possible. When the #include is missing from a header file, it will be inserted before the .generated.h, which should be the last one in the list of includes. The incorrectly placed #include is highlighted by the corresponding inspection.

In addition, auto-import no longer suggests symbols from Private and Classes folders of your UE4 project.

templated lambda

C++ language: C++17 and C++20

C++ understanding is enhanced further:

K&R style C declarations

K&R style C declarations

ReSharper C++ can now correctly handle C declarations in the K&R style. So if you have a legacy library using this kind of style or just prefer it for some reason, ReSharper C++ will now be able to work with it nicely:

Clang-Tidy settings


For a while now, ReSharper has provided seamless integration with Clang-Tidy, a powerful open-source code analysis tool based on the Clang compiler. In v2019.1, we’ve upgraded the built-in Clang-Tidy binary to Clang 8, to give you many new code checks and the accompanying fixes.

Clang-Tidy options are now grouped on a separate options page under Options | Code Editing | C++ | Clang-Tidy. You can list the checks you wish to enable/disable using a simple text form there, provide a Clang-Tidy config, and even provide a custom Clang-Tidy binary that will be used instead of the bundled one.

Base file members


To make the editor as responsive as possible, this release speeds up Search everywhere and Go to type. Go to file member, Go to base class, and Go to derived class searches are now available during indexing.

The performance of Go to Everything was also improved in several ways, including overall performance, search for patterns with :: or spaces, and other areas.

When calling Go to File Member, you can now include base members in the list and navigate to them as well.

Naming settings

Naming Convention

We’ve reworked the C++ Naming Convention settings page (ReSharper Options | Code Editing | C++ | Naming Style). Now you have two separate lists, specifiers and entity kinds (organized in a tree), and you can combine them and add rules specific to one or several kinds of entities.

Several new entity kinds were introduced to make the configuration even more flexible:

  • Template parameters were split into type and non-type template parameters.
  • Parameters were split into function and lambda parameters.
  • Enumerators were split into scoped and unscoped enumerators.
ClangFormat in ReSharper formatting settings


The formatter settings include many new options and enhancements:

  • To make the formatter more flexible, we’ve separated the formatting options for spaces around references and pointers. There are now two sets of options for each case, so, for example, you can add a space before a reference in the return type of a function, but skip it before the pointer.
  • You can wrap before the commas of a base class list.
  • Lots of new ClangFormat options are supported in ReSharper C++, such as CompactNamespaces, AllowShortBlocksOnASingleLine and AllowShortFunctionsOnASingleLine, AccessModifierOffset, BreakBeforeBraces: Custom, and many others.
  • In settings you can see now which formatting options are affected by a given ClangFormat options.


When you are typing a documentation comment in your code, a typing assist will automatically insert /// on a new line when you press Enter. If there is an XML documentation comment for a function and its parameter is being renamed via the Rename refactoring, then the corresponding <param> tag in the documentation comment will also be updated. That is not all: if you rename the parameter manually, ReSharper C++ will highlight the mismatch for you and will suggest adding a new <param> tag or renaming the existing one.

Doctest support

Unit testing

In unit testing, the following are now supported:

  • TEMPLATE_PRODUCT_TEST_CASE test declarations from Catch 2.7, and
  • The GTEST_SKIP() macro from Google Test.

Additionally, we’ve increased the number of supported frameworks (previously we covered Google Test, Boost.Test, and Catch) and added support for doctest. This is a relatively new framework which is lightweight and very flexible. It allows tests to be written directly in the production code and at the same time offers a way to remove everything test-related from the binary.

ReSharper C++ 2018.3


Responsive editor

ReSharper C++ 2018.3 offers several notable performance improvements. First, Find code issues and InspectCode command line tool are now parallelized, which makes them significantly faster. Second, Cache loading on project reopening is now parallel as well, which makes it twice as fast on average. Finally, there are general performance improvements in code completion, initial project indexing, and file analysis.

Unreal Engine

Unreal Engine support

Start working with your Unreal Engine 4 projects in mere seconds! When opening a solution, ReSharper C++ only parses non-engine projects, while the engine files are indexed in the background later. This means you can start typing or navigating through your project seconds after you open it!

Unreal Engine uses specific macros (UCLASS, USTRUCT, UENUM, etc.) to emulate missing reflection features in C++. These macros are now parsed by ReSharper C++ correctly, even before you build your Unreal Engine project.

C++/CLI improvements

Improved C++/CLI support Improved C++/CLI support Ultimate

Support for C++/CLI is enhanced in v2018.3, offering lots of smart ways to generate missing C++/CLI code:

  • Generate actions to generate .NET Equals() and GetHashCode()
  • Generate constructor and Generate getter/setter, which generates C++/CLI properties
  • On C++/CLI classes, you can also call Create derived class/struct/interface
  • Code completion works after objects of generic types in C++/CLI. Smart type completion, which filters the list of types, methods, and variables to match the expected type, now work after gcnew
  • New postfix templates, new and foreach, in C++/CLI code
  • You can also create a field and member function from the actual usage for C++/CLI classes

Better error diagnostics in templated code

When the overload resolution fails in C++, ReSharper C++ 2018.3 now provides a more specific description of the cause, identifying the exact requirements that aren’t satisfied. This is especially helpful for failed enable_if conditions, ill-formed expressions inside decltype, and absent inner types.

Learn more

templates completion

Code completion in dependent code

If that wasn't enough, completion now uses default template arguments to provide suggestions in dependent code.

Parameter info

Hints and parameter info

The Parameter Info popup shows even more information such as deleted functions, implicitly generated functions, and template parameter descriptions taken from documentation comments for template arguments. Parameter Info also works for dependent code and for user-defined binary operators. To finish things off, it’s now colored and more readable.

Name hints

C++ name hints in function calls and aggregate initialization can help you find your way through long (and sometimes nested) lists of parameters. You may also find useful the new name hints at the end of namespace definitions, right after the closing brace.

functional style cast

Code inspections and quick-fixes

More than 10 new inspections were added, many of them with matching quick-fixes to resolve the detected problems. For example, now there's a quick-fix you can use to add a functional-style cast and initialize all uninitialized members/bases. Meanwhile, integration with Clang-tidy was updated to Clang 7, bringing 50+ additional checks.

functional style cast

Refactorings and code tweaks

ReSharper's refactorings are now more knowledgeable about modern C++. When you use the Change Signature refactoring, you can now choose to make a function constexpr, const, or noexcept, as well as change the ref-qualifiers.

ReSharper C++ 2018.3 also introduced several new context actions to help improve your code base:

  • Generate a function implementation and copy it to the clipboard instead of inserting it into the document.
  • Generate a function that converts an enum to a string (customizable via a live template).
  • Convert a regular return type in a function declaration into a trailing return type, and vice versa.
  • Insert template arguments deduced using class template argument deduction.
unmatched signatures


Go to declaration now works on non-dependent decltype specifiers and lambdas (going to the lambda body). It even works during the initial project indexing, saving you even more time!

Search Everywhere, a universal search action, has added some additional filters. For example, /gf for global C++ functions, /gv for global C++ variables, or /d for macro definitions.

The handiest feature, however, has to be navigating to unmatched signatures. For example, when Go to declaration is called on a changed declaration of a member function, it goes to its definition with an old signature.

code style

Code Style

Often it's much easier to customize formatting settings by simply detecting them from the existing code. This is now possible! Use ReSharper | Edit | Detect formatting settings menu to have ReSharper detect code formatting settings. You'll get the tool window with the detected values, which can be reviewed and applied to the ReSharper settings on your machine. Or, you can save them to a team-shared settings layer so that other developers on your team will have the same code formatting configuration when opening the current solution. Learn more

ReSharper C++ can't auto-detect C++ naming schemes for now, but predefined C++ naming styles were added to the settings: STL, Google, LLVM, CamelCase, and Microsoft. Select it in ReSharper Options | Code Editing | C++ | Naming Style.

functional style cast

Unit testing with Catch

This release also provides support for Catch 2.5 and its new templated tests.

ReSharper C++ 2018.2


Initial C++/CLI support Initial C++/CLI support Ultimate

C++/CLI is a set of C++ language extensions by Microsoft for easy interoperability between managed and native code. With extensive support for both managed languages and C++, it is only natural for ReSharper to offer help with writing code in C++/CLI too.

However, with so many syntactic additions and peculiar changes to the C++ language semantics, handling C++/CLI is no easy task. But now the wait is over — ReSharper C++ 2018.2 makes C++/CLI support public, with many major features (including code inspections, typing assistance, formatting, and code completion) updated to support this language dialect.

Please remember that we are still working on improving C++/CLI support, and cross-language navigation and refactorings are a work in progress. As we move to expand our coverage we would love to hear your feedback on what is missing and what you feel we should concentrate on.

C++/CLI support requires a ReSharper Ultimate subscription and the ReSharper product to be enabled. To learn more, see C++/CLI support comes to ReSharper C++.

C++17 features

C++17 features

Another area that we’ve been putting a lot of effort into is our ongoing work on support for C++17. ReSharper C++ 2018.2 adds understanding of the following new features:

  • Class template argument deduction and user-defined deduction guides.
  • Fold expressions.
  • Auto non-type template parameters.
  • Pack expansions in using declarations.
  • Using declarations with multiple declarators.
  • Guaranteed copy elision.
  • Aggregates with base classes.
  • std::is_aggregate type trait support.
  • __has_include preprocessor macro.

All in all, these updates mean that most of the major C++17 features are now supported by ReSharper C++, with the two biggest omissions being hexadecimal floating point literals and noexcept as a part of the function type.

C++20 features

C++20 features

The C++20 standard is already shaping up and its features are becoming available in major compilers. Keeping up with the evolution of the language, ReSharper C++ now supports several features from the upcoming standard:

  • Coroutines (as specified in the n4760 Coroutines TS draft).
  • Designated initialization.
  • Range-based for statements with initializer.
  • Feature test macros.
  • Default member initializers for bit-fields
Integrated spell checking

Integrated spell checking with ReSpeller

ReSharper C++ 2018.2 provides spell-checking functionality out of the box, thanks to the newly bundled ReSpeller extension which has also been updated to support the C++ language. Just like with code analysis, ReSpeller scans for spelling mistakes and typos in identifiers, comments, and string literals, and provides quick-fixes to resolve these problems.

When you encounter a spelling mistake, you can invoke the Alt+Enter menu and ReSpeller will provide several options to fix the problem: we can either fix the typo or add this word to ReSpeller's dictionary. By default, the spell checker comes with a built-in dictionary for English (United States), but dictionaries for other languages can be easily added too.

For instructions on adding a new dictionary and more info about ReSpeller, see Integrated spell checking with ReSpeller in ReSharper and Rider.

Formatting inspections

Formatting inspections

Every now and then, you want to be notified directly in the code when you are not following formatting rules. With this in mind, ReSharper's code formatting engine introduces inspections and quick-fixes for formatter-related problems: inconsistent indenting, line breaks, spaces, and blank lines can now be observed and fixed directly in the code editor.

By default, formatting inspections are disabled so as not to bother anyone who doesn't care about formatting during typing. Go to ReSharper | Options | Code Inspection | Inspection Severity | C++ | Formatting to see all the available inspections and select severity levels for those of them that you wish to be notified of.

To learn more, see Maintaining consistent code style with formatting inspections.

Param info

Other changes

As usual, ReSharper C++ 2018.2 comes with many smaller improvements in different areas:

  • When performing size and alignment calculations, the code analysis engine takes into account bit-field sizes, alignas specifiers, and __decltype(align) attributes.
  • Parameter Info provides details about members of the aggregate class when performing aggregate initialization.
  • Comments in a code file to override formatter settings can be generated directly from the Configure Format dialog.
  • Range-based for statements provide references over the colon for easy navigation to the begin() and end() functions used by the loop.
  • Separate color settings for static class fields and static member functions were added.
  • Expected failures specification is supported in Boost.Test unit tests.
  • A lot of performance fixes in different areas of ReSharper were made, from speeding up ClangFormat support to decreasing solution loading time. More detailed information is available in the performance blog post series dedicated to the ReSharper 2018.2 release.

ReSharper C++ 2018.1

Debug Step Filters

Debug Step Filters

Step Filters is the latest addition to the host of features provided by ReSharper C++ for debugging. When you invoke Step Into, the Visual Studio debugger will normally step into all the functions that are called from the current statement. However, some of the functions are either trivial or so well tested, that you don’t want to step into them. This is where Step Filters comes in: with this feature you can specify functions that should always be stepped over by the debugger.

ReSharper C++ comes with a predefined collection of step filters for the standard library, but you can always add new ones:

  • You can inspect, configure, disable or enable back step filters on the Tools | Debugging | C++ options page, which has a list of all the available step filters.
  • When you step into a function and decide that you want to step over it in the future, you can use a context action to quickly add this function to the list of step filters. For template functions, there are separate context actions to add either only the current instantiation of the function or all its instantiations.

To learn more, see Step Filters in ReSharper C++.

Includes Analyzer

Includes Analyzer

Compilation times are one of the biggest problems in large real-world C++ projects. ReSharper C++ 2018.1 introduces the Includes Analyzer, a new code inspection tool which helps you gauge which header files in your project contribute the most in terms of lines of code to the total compilation workload. To use it, invoke one of the ReSharper | Inspect | Analyze Includes in … actions or select Analyze Includes from the context menu in the Solution Explorer. ReSharper C++ will analyze the files in the given scope and give a report in a dedicated tool window.

The report lists files sorted by the number of lines of code they contribute together with their transitively included files. You can then dig into dependencies between the files either with the Includees tree view where child nodes correspond to the files that include the file in the parent node, or the Includers tree view where child nodes are the included files. Using these two views, you should be able to pinpoint the header files that contribute the most and then try to get rid of any unnecessary #include directives.

Navigation improvements

Navigation improvements

The Go to File Member dialog has been redesigned. Class members are now grouped by their containing class in the results list. Moreover, with no search, active file members are sorted in the order of their declarations, and the scrolling list with the results accommodates more items. Together these changes improve the usability of the dialog by providing clearer insight into the structure of the current file.

In all Go to dialogs and several other places ReSharper C++ now attempts to shorten symbol names that are excessively long by cutting out the function and template parameters.

When you perform a search using the Recent Files dialog, Go to File search results are also appended to the results list after the Recent File items.

Finally, the option to remember the last search in the Search Everywhere dialog is now on by default. You can revert to the old behavior through the Environment | Search & Navigation | Remember last search setting.

Command-line code cleanup

Command-line code cleanup

ReSharper Command Line Tools, a free standalone collection of tools that can be used from the command line or as a part of the continuous integration process, now lets you perform code cleanup in C++ projects. Run cleanupcode.x86.exe on your solution, and it will automatically reformat your code, remove common redundancies, apply Clang-Tidy fix-its and common code style fixes. This instantly eliminates code style violations in a project or a solution, and ensures a uniform code base.

In related news, bogus errors which were output by the InspectCode tool on x64 projects were fixed in this release. In addition, TeamCity 2018.1 is able to run InspectCode on C++ projects (see TW-48978 for details).

To learn more, see Code Cleanup with the ReSharper Command Line Tools.

Code inspections

Code inspections

ReSharper C++ adds the following new built-in inspections:

  • New inspection (with a corresponding fix and a code cleanup item) that suggests replacing if statements with if constexpr statements when the condition is a compile-time constant expression.
  • A set of inspections to diagnose usages of deleted functions.
  • Control flow and usage checking inspections have been updated to work inside lambda bodies.
More ways to configure inspection severities

More ways to configure inspection severities

In ReSharper С++ 2018.1, .editorconfig files can now be used to set inspection severities for any scope: the entire solution, a project, or even a specific file. Besides this, inspection severity settings can be read from the project’s DotSettings file. It means that different projects can have different sets of enabled/disabled inspections or different inspection severities.

Check the Read settings from EditorConfig and project settings option on the Code Inspection | Settings | General options page to enable this feature.

To learn more, see Configuring inspection severities with EditorConfig.

Clang-Tidy integration updates

Clang-Tidy integration updates

Clang-Tidy integration has received a few enhancements:

  • Bundled Clang-Tidy has been updated to version 6.0, which brings several new checks.
  • A new inspection action lets you disable a specific Clang-Tidy check in the current line by its name.
  • When the Clang-Tidy executable crashes, no system error dialogs will be shown from now on.
Other improvements

Other improvements

Other changes to ReSharper C++ include the following:

  • The #include_next preprocessor directive is now supported, for better compatibility with compilers that implement this GNU extension.
  • Typing assistance in C++ files automatically removes trailing whitespaces on Enter in order to keep your code clean of redundant whitespaces.
  • If you select an expression and open the Quick Documentation window, it will show various information about the selected expression, such as its type, value, and value category.
  • The new Tools | Unit Testing | C++ Tests | Use command-line arguments … setting controls whether ReSharper C++ should use the value of the Debugging | Local Windows Debugger | Command Arguments project property when running unit tests.
  • Performance of the completion pop-up has been improved.

ReSharper C++ 2017.3

Debugger features

Debugger features

ReSharper С++ 2017.3 brings the debugger into the editor: local variables, function parameters, current line expressions and function return values are now displayed inline right next to the corresponding code. In addition, ReSharper C++ comes with the new Go to Breakpoint action (Ctrl+Alt+F9) and the R# Breakpoints tool window for quick navigation between breakpoints in the solution, as well as the ability to create breakpoints and tracepoints from the Find Results tool window.

ReSharper C++ also provides its own debugger DataTips with the ability to search inside them for a specific value. To access ReSharper DataTips, click the inline value display or replace Visual Studio DataTips in the Tools | Debugger ReSharper options page.

Clang-Tidy integration

Clang-Tidy integration

Clang-Tidy is a powerful open-source code analysis tool, based on the popular clang compiler. It comes with the extensive set of code checks and accompanying fixes. ReSharper C++ 2017.3 provides seamless integration with Clang-Tidy, meaning that it simply works in the background as you edit your code, with inspection results shown on-the-fly in the code editor along with built-in inspections. ReSharper C++ also lets you apply the fixes provided by Clang-Tidy individually, as scope actions, or from Code Cleanup.

In addition to the diagnostics from Clang-Tidy checks, Clang-Tidy also issues diagnostics from the Clang Static Analyzer and warnings provided by the clang compiler itself. All of them have corresponding ReSharper inspections with configurable severity levels, which can be tuned according to your needs.

Please note that files using UTF-16 or UTF-32 encoding are not supported by Clang-Tidy at the moment.

Better C++ language understanding

Language understanding

Improving C++ understanding was a major focus of the 2017.3 release, with several C++17 and C++14 features now supported:

  • C++17 structured binding declarations.
  • C++17 inline variables.
  • C++17 constexpr if statements.
  • Deduction of return type for auto functions without trailing return type from C++14.
  • Type checking and return type deduction for lambda expressions, including support for C++14 generic lambdas.

The rest of the language-related changes include:

  • Support for include_alias pragma directives.
  • Improved handling of explicit template instantiations.
  • Support for the event handling Microsoft C++ extension.
Add missing function parameter description

Code inspections and context actions

ReSharper C++ 2017.3 comes with a set of new code inspections with accompanying fixes:

  • Binary operator with identical or equal arguments.
  • Redefinition of a default function argument from another declaration or a base function.
  • Redundant const specifier on a parameter in a function declaration.
  • Missing function parameter description in a documentation comment.
  • Redundant member initializer in a member initializer list.
  • Non-inline variable definition in a header file.
  • User-defined literal suffix that does not start with an underscore.
  • Detailed diagnostics about errors in structured binding declarations.

A couple of new context actions were also added:

  • Convert a member initializer in a member initializer list into a non-static data member initializer.
  • Switch between class and typename keywords in a type template parameter declaration.
New Code formatting features

Code formatting

Formatter can now be enabled/disabled from comments and configured using inline EditorConfig-style settings. It also adds a number of new options for more flexible formatting, including options that control:

  • Multiline code formatting:
    • Aligning code in columns for assignments, declarations, and single-line comments.
    • Outdenting commas and member access operators in chained method calls.
  • Spaces before/after commas in uniform initialization braces and before end of line comments.
Go to Declaration

Go to Declaration improvements

The Go to Declaration command is now available on dependent names inside definitions of templates. Since ReSharper C++ has no means to find the exact entity that the name refers to, instead all symbols with matching names and signatures will be found and offered as potential navigation targets.

Furthermore, Go to Declaration now lets you navigate from a function definition to a declaration with a non-matching signature, if no matching declarations are found.

The Performance Guide page

Performance Guide

ReSharper Performance Guide collects a set of Visual Studio and ReSharper settings that might affect overall performance in one place and provides a way to quickly change them. The Performance Guide page can be found in ReSharper options, under Environment | Performance Guide.

To-do items support linking to external resources

Other changes

  • Catch2, the latest version of the popular Catch unit testing framework, is supported.
  • To-do items support linking to external resources.
  • Redesigned preview pane in ReSharper tool windows and formatter options pages.
  • Find Usages window supports multi-line occurrences.
  • Search Everywhere always shows text matches, even when there are other results.