Coding Assistance in C++

Automatic and basic completion

In C++ files, you can use automatic and basic Ctrl+Space completion when writing your code. For example, you can quickly add enum members taken from a different namespace:

The selected completion item displays a popup with syntax-highlighted signature and documentation. If necessary, you can disable this popup by clearing the Show summary checkbox on the Environment | IntelliSense | Completion Appearance page of ReSharper options (Alt+R, O).

Import symbol completion

When a symbol that you want to use is not imported in the current file with the corresponding #include, but it is defined in the standard libraries or elsewhere in your solution, you can press Alt+Shift+Space to quickly find this symbol in completion suggestions:

Note that this comes with a performance hit (since each time when ReSharper builds a completion list, it has to look at all the symbols in the solution to match them), so it is disabled by default.

Dot/arrow completion helpers

When you call a method, you can always type a dot . or an arrow -> and get all available methods in the completion list. The methods that do not match ./-> are displayed in grey. If you choose such method, the ./-> will be corrected automatically:

Generative completion

Generative completion suggestion are also available. For example, when you call a member function declaration on the object...

ReSharper generates the following function:

Postfix completion

Postfix completion in C++ is very much like C# extension methods. If you type a dot . or an arrow -> after an expression, ReSharper will suggest free functions that would accept that expression as the first parameter. When you accept the suggestion, ReSharper will rewrite your code so that the expression is passed as the first argument:

Gif

Postfix completion also includes postfix templates which, instead of looking up for suitable methods, let you quickly wrap an expression with frequently used language constructs.

Free functions in code completion

One common C++ coding practice is to prefer non-member non-friend functions to member functions. This is a great way to increase encapsulation and keep class interfaces as minimal as possible. When you type a dot . or an arrow -> after an expression, free functions that accept the expression as the first parameter will be suggested in the completion list after member functions:

Gif

If you do not want to have free functions in the completion suggestions, you can clear the corresponding checkbox on the Code Editing | C++ | Code Completion page of ReSharper options (Alt+R, O).

Code completion in dependent code

ReSharper automatically uses default template arguments to provide completion suggestions in dependent code. When typing inside a template body, code completion may be unavailable if there is no type information for parameters. However, for template parameters that have default arguments ReSharper will provide completion suggestions based on those default arguments.

Code completion for an import item

When Import Symbol completion is enabled, ReSharper’s completion list also suggests items from headers which are not included in the current file. If a class is not included in the current file, the completion list will suggest two options: insert an include directive, or add a forward declaration. A context menu with both options is shown by default, but you can change the default behavior on the Code Editing | C++ | Code Completion page of ReSharper options (Alt+R, O).

Gif

Convert enum to string (generate enum-to-string helper)

This context action generates a helper function for a specific enum that converts its enumerators to corresponding strings.

For example, if you invoke this action on the following enum:

enum class Suit { Diamonds, Hearts, Clubs, Spades };

ReSharper will generate the following function for you:

const char* to_string(Suit e)
{
    switch (e)
    {
    case Suit::Diamonds: return "Diamonds";
    case Suit::Hearts: return "Hearts";
    case Suit::Clubs: return "Clubs";
    case Suit::Spades: return "Spades";
    default: return "unknown";
    }
}

If necessary, you can customize generated function by editing the enum_to_string live template that ReSharper uses for generation. For example, you can configure the template to generate stream output operator overload:

std::ostream& operator <<(std::ostream& out, Suit e)
{
    switch (e)
    {
    case Suit::Diamonds: return out << "Diamonds";
    case Suit::Hearts: return out << "Hearts";
    case Suit::Clubs: return out << "Clubs";
    case Suit::Spades: return out << "Spades";
    default:
       assert(false);
       return out << "unknown";
    }
}

Generate missing case statements

Instead of manually writing all case statements when switching over an enum, you can use the context action that generates all missing case statements:

Merge nested 'if' statements

ReSharper helps you merge nested 'if' statements with the context action:

Generate implementation

ReSharper helps you automatically create a stub implementation of a function or a method. You can always generate an inline implementation and, if the function is defined in a header file and there is the corresponding source file, you can generate the implementation in the source file.

tip

You can quickly create a declaration for an existing method implementation with a quick-fix.

Move implementation out of class scope

ReSharper helps you move the implementation of a function or a method from a header to the corresponding source file if it exists. After applying this context action the definition is left in its original place and the implementation is moved to the source file. The editor context is switched to the source file as well.

You can also use the context action to move all implementations in the current selection.

Document entity

With this context action, you can generate documentation comments for C++ symbols. If necessary, you can customize the comment stub by editing the doc live template that ReSharper uses for generation.

Gif

This action is also available with the dedicated shortcut Ctrl+/ and from the menu: ReSharper | Edit | Document.