Coding Assistance in C++

In C++ files, you can use automatic and basic CtrlSpace 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 the parameter info popup in _ ms checkbox on the Editor | General | Code Completion page of JetBrains Rider settings CtrlAlt0S.

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 AltShiftSpace to quickly find this symbol in completion suggestions:

Optionally, you can include import symbol suggestions into the suggestion lists of automatic and basic completion by selecting Show import items in basic completion on the Languages & Frameworks | C++ | Code Completion page of JetBrains Rider settings CtrlAlt0S.

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

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 suggestion are also available. For example, when you call a member function declaration on the object...

JetBrains Rider generates the following function:

Postfix completion in C++ is very much like C# extension methods. If you type a dot . or an arrow -> after an expression, JetBrains Rider will suggest free functions that would accept that expression as the first parameter. When you accept the suggestion, JetBrains Rider 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.

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 Languages & Frameworks | C++ | Code Completion page of JetBrains Rider settings CtrlAlt0S.

JetBrains Rider 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 JetBrains Rider will provide completion suggestions based on those default arguments.

When Import Symbol completion is enabled, JetBrains Rider’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 Languages & Frameworks | C++ | Code Completion page of JetBrains Rider settings CtrlAlt0S.

Gif

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 };

JetBrains Rider 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 JetBrains Rider 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";
    }
}

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

All you have to do then is to write the required logic for each statement.

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

JetBrains Rider 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.

JetBrains Rider 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.

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 JetBrains Rider uses for generation.

Gif