# ReSharper C++ 2026.3: Class Layout, Format String Analysis, And More

> Source: <https://blog.jetbrains.com/rscpp/2026/11/10/resharper-cpp-2026-3-class-layout-format-string-analysis-and-more/>
> Published: 2026-11-10 16:37:04+00:00

## 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: Class Layout, Format String Analysis, And More

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}](https://fmt.dev/) 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 `double` with the`d` presentation 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](https://releases.llvm.org/23.1.0/tools/clang/tools/extra/docs/ReleaseNotes.html#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 as`printf` and`malloc` ), 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`goto` and`return` statements inside loops in`__tile_global__` functions, as well as tile kernels launched with a block size other than`1` . A suggestion also detects loops that can be replaced with a range-based`for` over`cuda::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 in*OOP* mode.
- Visual Studio’s *F8* and*Shift+F8* shortcuts navigate between ReSharper’s*Find Usages* results.
- The *New from Template* command is once again available in the*Solution 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**](https://entry.i18n.w3jbcom.aws.intellij.net/resharper/whatsnew/) 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.

#### Subscribe to ReSharper C++ Blog updates