Getting started with C++

JetBrains Fleet supports C++ projects with compilation databases.

A compilation database is a JSON file named compile_commands.json, which contains structured data about every compilation unit in the project.

• Follow this instruction to generate a compilation database for your project.

tip

Your compile_commands.json can be located anywhere under the project root. Fleet checks all the workspace directories at picks the largest compile_commands.json file.

1. Press Ctrl0O or select File | Open from the menu.

2. Select your project root folder and click Open:

   

3. The opened directory becomes the root of your workspace:

   

Smart Mode turns on code insight features for your C++ code.

• Click the Smart Mode Status icon in the top-right corner. In the popup that appears, click Enable.

  

The following message indicates that JetBrains Fleet might not have been able to download Clangd due to a firewall restriction.

Follow these steps to manually install Clangd as a workaround:

1. Download Clangd from the Maven repository.

   note

   The latest Clangd versions now include an architecture suffix (for example, -x64 or -aarch64). Be sure to select the correct version for your system.

2. Copy the downloaded files to the corresponding JetBrains Fleet directory:

   • For JetBrains Clangd:

     /home/user/.cache/JetBrains/Fleet/language_server/jbclangd/*

   • For Upstream Clangd:

     /home/user/.cache/JetBrains/Fleet/language_server/clangd/*

3. Restart JetBrains Fleet.

• All the errors in your code are highlighted red:

  

• Context-aware completion gives a list of suggestions for names, types, and keywords:

  

• Among the completion suggestions, you can find templates for common code constructs. Select one from the list, and then use Tab to move the caret between stubs:

  

  Available code snippets:

  • typedef [type] [name];

  • using [name] [type];

  • namespace [name] = [namespace];

  • using namespace [identifier];

  • using [qualifier]::[name];

  • using typename [qualifier]::[name];

  • template<class [name]>

  • template<typename [name]>

  • switch ([condition]) { [cases] }

  • case [expression]:

  • goto [label];

  • dynamic_cast<[type]>([expression])

  • static_cast<[type]>([expression])

  • reinterpret_cast<[type]>([expression])

  • const_cast<[type]>([expression])

  • catch ([declaration]) { [statements] }

  • concept [name] = [constraint];

  • #define [macro]([args])

• To transform an already typed expression into a different one without moving the caret, add a dot at the end. You will see postfix completion options among the list of suggestions:

  

  For example, you can choose if, and the initial expression will get wrapped into an if statement:

  

• Press Ctrl0I to get the list of parameter names in a function call:

  

  Click Show all to view all the usages.

• Hover over a class, function, field, or another element to see where and how it is defined:

  

• Select an item to be renamed, press F2, and enter the new name:

  

• Navigate to the declaration of a symbol with Ctrl0B.

• Find usages of a symbol with Ctrl0U:

  

• Skim over the errors with Ctrl0E and CtrlShift0E.

Fleet does not provide automation for the process of building a running C/C++ applications.

However, you can use Fleet's language-agnostic run configurations for that. Find below an example for the case of CMake:

{
    "configurations": [
        {
            "type": "command",
            "name": "Build",
            "program": "cmake",
            "args": ["--build", "$PROJECT_DIR$/cmake-build-debug", "--target", "program_name"],
        },
        {
            "type": "command",
            "name": "Run",
            "program": "$PROJECT_DIR$/cmake-build-debug/program_name",
        },
    ]
}