ReSharper C++ #
The Visual Studio Extension for C++ Development
[.NET Tools](https://blog.jetbrains.com/rscpp/category/net-tools/)
[News](https://blog.jetbrains.com/rscpp/category/news/)
[Releases](https://blog.jetbrains.com/rscpp/category/releases/)
[Resharper C++](https://blog.jetbrains.com/rscpp/category/resharpercplusplus/)
ReSharper C++ 2026.3 is here, with a new Class Layout tool window that visualizes the memory layout of your classes and helps you spot wasted space..
This release also improves format string analysis to cover std::format, std::print, and the {fmt} library. Other highlights include updates to the Change Signature and Extract Method refactorings, as well as new CUDA inspections.
Class layout #
How a class is laid out in memory determines how much space each object takes, how well its data fits into CPU cache lines, and whether it matches a binary format or an ABI shared with other code. To satisfy alignment requirements, the compiler silently inserts padding between fields. As a result, a class can end up noticeably larger than the sum of its members. This can add up quickly for objects allocated in large numbers or processed in tight loops.
The new Class Layout tool window visualizes the memory layout of a class, struct, or union, including the offset and size of every field and bit-field, base class subobjects, virtual table pointers, and the padding between them. This makes it easy to find padding you can eliminate, check the effect of alignas or #pragma pack, and understand the layout of classes in a complex hierarchy. To open the tool window, place the caret on a class name or any reference to a class type, then choose ReSharper | Inspect | Class Layout. Alternatively, select the Class Layout item in the Alt+Enter menu.
Refactorings #
Change Signature for constructors
The Change Signature refactoring now works on constructors. You can add, remove, reorder, and change the types of constructor parameters, and ReSharper C++ updates the constructor calls throughout your code, including direct and braced initialization, new expressions, member and base class initializers, and factory functions such as std::make_unique. The Change Signature dialog also has two new options that let you add or remove the static specifier on functions and the explicit specifier on constructors.
Note: Some constructor calls, such as implicit conversions or calls through a custom factory template, can’t be found and therefore aren’t updated.
Extract Method placement
The Extract Method refactoring now has a Place in option that controls where the extracted function is placed: either next to the current function, as a free function in the namespace containing the current class, or as a free function in an anonymous namespace. A new Make constexpr option also lets you mark the extracted function constexpr.
Introduce Using Directive
The new Introduce Using Directive refactoring replaces namespace qualifiers, such as std in std::cout, with a using namespace directive.
Format string analysis #
std::format, std::print, and {fmt}
ReSharper C++ has long analyzed calls to printf-like functions. In 2026.3, the same analysis extends to the C++20 <format> and C++23 <print> standard library headers, as well as the popular {fmt} library. ReSharper C++ now analyzes calls to format, format_to, format_to_n, formatted_size, print, and println from both the std and fmt namespaces:
-
Replacement fields in the format string are highlighted. When the caret is on a replacement field, the corresponding argument is highlighted too, and vice versa.
-
ReSharper C++ reports invalid replacement fields, missing and unused arguments, and format strings that mix automatic and manual argument indexing.
-
The format specification is checked against the argument type. For example, formatting a
doublewith thedpresentation type is reported, and a quick-fix replaces it with a matching one. -
Named arguments are supported for the {fmt} library via
fmt::arg.
printf updates
The analysis of printf-like functions now supports the new format specifiers from C23. ReSharper C++ also understands POSIX positional arguments such as %1$s and %2$*1$d, and checks the argument types by position. A new inspection reports printf calls that mix positional and non-positional arguments.
Unreal Engine logging macros
Format string analysis now supports UE_LOGFMT and related Unreal Engine structured logging macros. ReSharper C++ highlights the fields in the format string, matches them with the arguments, and reports missing or unused arguments and invalid field names.
Format attributes on constructors
The [[jetbrains::format]] and [[gnu::format]] attributes can now be applied to constructors, so ReSharper C++ checks the format string in constructor calls. Additionally, ReSharper C++ now recognizes the underscore spelling of the attribute, [[__gnu__::__format__(__printf__, 1, 2)]], as well as constant expressions in the attribute’s argument indices.
Code analysis #
Clang-Tidy integration
The bundled Clang-Tidy binary has been updated to LLVM 23, bringing new checks and improvements from the latest LLVM release. Clang-Format has been updated as well.
NOLINT comments with globs in check names, such as // NOLINT(readability-*), now also suppress the ReSharper C++ inspections that correspond to the matching Clang-Tidy checks. Moreover, a new Additional clang-tidy command-line arguments setting on the Clang-Tidy options page lets you pass extra arguments to Clang-Tidy.
Explanations for failed constraints
When a requires expression evaluates to false, ReSharper C++ now shows which requirement fails and why its expression is ill-formed. For example, a function or operator may be inaccessible or deleted, or the number of arguments may not match the candidate functions. Similarly, error messages about deleted constructors and failed destructibility checks now show the full chain of reasons, down to the specific base class or field that causes the problem.
CUDA
ReSharper C++ 2026.3 extends its CUDA support with a new set of inspections, which you can configure in the new CUDA group on the inspection severity settings page:
- Execution spaces : ReSharper C++ checks that a function can be called from the CUDA execution space of the calling code, following the rules of the CUDA Programming Guide. The check takes into account
__CUDA_ARCH__guards, CUDA runtime API functions, C library functions available in device code (such asprintfandmalloc), and calls to overloaded operators. - Memory spaces : New inspections detect invalid uses of the
__device__,__constant__,__shared__,__managed__, and__grid_constant__specifiers. Examples include memory space specifiers on data members or function parameters, initializers on__shared__variables, and conflicting specifiers. - CUDA Tile : New inspections enforce the restrictions of the CUDA Tile programming model. For example, they report
gotoandreturnstatements inside loops in__tile_global__functions, as well as tile kernels launched with a block size other than1. A suggestion also detects loops that can be replaced with a range-basedforovercuda::tiles::irange.
Language support
ReSharper C++ 2026.3 supports more features from recent C++ standards:
- C++23 delimited escape sequences: `\x{...}` ,`\o{...}` , and`\u{...}` ([P2290](https://wg21.link/p2290) ).
- C++26 user-generated `static_assert` messages ([P2741](https://wg21.link/p2741) ).
- C++26 `offset` parameter of the`#embed` directive ([P3540](https://wg21.link/p3540) ).
- C++26 `#line` directives before module declarations ([P3868](https://wg21.link/p3868) ).
Visual Studio integration #
Out-of-Process mode
In ReSharper 2026.2, Out-of-Process (OOP) mode became the default. It moves heavy analysis work out of the Visual Studio process, helping prevent UI freezes and keep typing smooth. In this release, we continue to polish OOP mode and fix some of the remaining issues:
- Includes Analyzer is now available inOOP mode.
- Visual Studio’s F8 andShift+F8 shortcuts navigate between ReSharper’sFind Usages results.
- The New from Template command is once again available in theSolution Explorer context menu for C++ projects.
Unit testing in CMake projects
CMake projects opened in Visual Studio’s Open Folder mode are now built before unit tests are run, according to the Build Policy setting of the unit test session.
Tell us your thoughts #
This post covered the highlights of improvements in C++ support. Take a look at the What’s New in ReSharper 2026.3 page to learn about all the other changes introduced in this release. Among them, ReSharper 2026.3 brings Claude and Codex into Visual Studio alongside Junie.
Download the latest release and let us know how it works for your projects.