The answer is here: How to use C/Cpp extension and add includepath to configurations.

Click the light bulb and then edit the JSON file which is opened. Choose the right block corresponding to your platform (there are Mac, Linux, Win32 – ms-vscode.cpptools version: 3). Update paths in includePath (matters if you compile with VS Code) or browse.paths (matters if you navigate with VS Code) or both.

Thanks to @Francesco Borzì, I will append their answer here:

You have to Left 🖰 click on the bulb next to the squiggled code line.

If a #include file or one of its dependencies cannot be found, you can also click on the red squiggles under the include statements to view suggestions for how to update your configuration.

[]

If you are working with cmake-tools and the error messages say something is wrong with the configurationProvider, then you have 2 options:

1. Use ms-vscode.cpptools instead of ms-vscode.cmake-tools
2. Define the headers in CMakeLists.txt

Option 1: Use ms-vscode.cpptools instead of ms-vscode.cmake-tools.

1. Open c_cpp_properties.json. (windows key on windows or cmd key on mac + shift + p, enter "c/c++ edit configurations" and chose 'json'.
2. Enter ms-vscode.cpptools as value for configurationProvider instead of ms-vscode.cmake-tools or whatever you have.

How it should look like after the replacement of configurationProvider:

One other important configuration is the include path. The assumption is that you have this configuration right. May be like following

Option 2: Define the headers in CMakeLists.txt

When configurationProvider is set to ms-vscode.cmake-tools in c_cpp_properties.json, VS Code uses the include information defined in the CMakeLists.txt instead of reading the includePath configs in VS Code.

So you need to setup the include path correctly:

1. using the include_directories command (rather than the target_include_directories command) to define the headers
2. Configure the project to reflect the change happened in the previous step.

• Left mouse click on the bulb of error line
• Click Edit Include path
• Then this window popup

• Just set Compiler path

I'm on a Macbook M1 Pro, and I had red squiggly error lines all over my C++ files. To solve, I did this:

1. Open Preferences -> Settings
2. Search for intelliSenseEngine
3. Change "C_Cpp: Intelli Sense Engine" from Default to Tag Parser

alternatively, you could create a .vscode folder in your project root, and then create a settings.json with the content of

{
    "C_Cpp.intelliSenseEngine" : "Tag Parser"
}

ideally, you should have a c_cpp_properties.json file in the same folder with the right settings as well.

Note: I got this idea from Github here.

I ended up here after struggling for a while, but actually what I was missing was just:

If a #include file or one of its dependencies cannot be found, you can also click on the red squiggles under the include statements to view suggestions for how to update your configuration.

source: https://code.visualstudio.com/docs/languages/cpp#_intellisense

The error message "Please update your includePath" does not necessarily mean there is actually a problem with the includePath. The problem may be that VSCode is using the wrong compiler or wrong IntelliSense mode. I have written instructions in this answer on how to troubleshoot and align your VSCode C++ configuration with your compiler and project.

Go to your c_cpp_properties.json file by searching from settings.There you might see the following code

{
    "configurations": [
        {
            "name": "Linux",
            "includePath": [
                "${workspaceFolder}/**"
            ],
            "defines": [],
            "compilerPath": "/usr/bin/gcc",
            "cStandard": "gnu17",
            "cppStandard": "c++17",
            "intelliSenseMode": "linux-gcc-x64"
        }
    ],
    "version": 4
}

Change the compiler path as below

"compilerPath": "/usr/bin/g++",

I was trying a hello world program, and this line:

#include <stdio.h>

was underlined green. I tried:

1. Deleting the line
2. Re-writing the line
3. Clicking the yellow bulb and choosing to update

fixed the error warning. i don't know if it fixed the actual problem. But then i'm compiling via a linux VM on Windows 10

Faced this issue with Mac M1 chip and was unable to compile and run a .cpp file which had #include <bits/stdc++.h> header.

Upon investigation I got to know that the <bits/stdc++.h> header is not part of the C++ standard; rather, it's a header file specific to the GNU Compiler Collection (GCC). Apple Clang, being a different compiler, may not include this header by default.

• So, specific to your project configurations, you can set the compilerPath to point at the path where you have installed the GNU g++ compiler.
• To find out if you have ever installed GNU gcc compiler with homebrew before, use the command brew info gcc. This will give out the version of the compiler if it exists with homebrew list.
• Use the command which g++-{your-specific-version} eg. which g++-13, in my case this gave the output of /opt/homebrew/bin/g++-13 which I then used to set the compilerPath in C/C++ Configuration file as well as the tasks.json file attached below.

//for c++17 build
{
    "version": "2.0.0",
    "tasks": [
        {
            "label": "compile",
            "type": "shell",
            "command": "/opt/homebrew/bin/g++-13",
            "args": [
                "-std=c++17",
                "-o",
                "${fileBasenameNoExtension}",
                "${file}"
            ],
            "group": {
                "kind": "build",
                "isDefault": false
            }
        },
        {
            "label": "compile and run",
            "type": "shell",
            "command": "/opt/homebrew/bin/g++-13 -std=c++17 -o ${fileBasenameNoExtension} ${file} && ./${fileBasenameNoExtension} < input.txt > output.txt",
            "group": {
                "kind": "build",
                "isDefault": true
            }
        }
    ]
}

For me, using Ubuntu, I just had to install gcc to solve this issue.

sudo apt install gcc

Then, set the compiler path to gcc. Go to your c_cpp_properties.json file, set:

"compilerPath": "/usr/bin/gcc"

An alternative answer would be opening VS Code in remote WSL, if you going to compile files with g++. Just close your VS Code and open WSL and type code . After that the File Explorer shows that VS Code is now running in the context of WSL with the title bar [WSL: Ubuntu]. But make sure you'd installed the GNU compiler tools and the GDB debugger on WSL.

source: https://code.visualstudio.com/docs/cpp/config-wsl

after you install the c/c++ extension, two files are created inside .vscode folder.

open c_cpp_properties.json file and paste this key-value pair inside configuration object.(if it doesn't already exists)

"configurationProvider": "ms-vscode-cpptools"

if it does already exists in the object, see if the value part is ms-vscode-cmaketools. if such it is, replace that existing line with above line.

this will allow you to execute your cpp files along with c files.

• For Windows:

1.Install Mingw-w64

2.Then Edit environment variables for your account "C:\mingw-w64\x86_64-8.1.0-win32-seh-rt_v6-rev0\mingw64\bin"

3.Reload

• For MAC

  1.Open search ,command + shift +P, and run this code “c/c++ edit configurations (ui)”

  2.open file c_cpp_properties.json and update the includePath from "${workspaceFolder}/**" to "${workspaceFolder}/inc"

If someone have this problem, maybe you just have to install build-essential.

apt install build-essential

I solved the error on my Mac by just clicking on the Edit "include path settings" and changing the compiler path to /usr/bin/clang.

In my case I did not need to close the whole VS-Code, closing the opened file (and sometimes even saving it) solved the issue.

I had luck removing the comments from c_cpp_properties.json in the .vscode folder. Comments aren't permitted in json files by default and you can't simply rename it .jsonc. Referenced In VS Code, disable error "Comments are not permitted in JSON"

My header file was in include/head.h, code in src/code.cpp. I wrote

#include "head.h"

and got this error. Changing it to

#include "../include/head.h"

fixed it.

I solved this problem, once I removed configurationProvider node and set cStandard and cppStandard to default values:

{
    "configurations": [
        {
            "name": "Linux",
            "includePath": [
                "${workspaceFolder}",
                "${workspaceFolder}/**",
                "${workspaceFolder}/test",
                "/opt/qt5/include/QtCore",
                "${workspaceFolder}/test"
            ],
            "defines": [],
            "compilerPath": "/usr/bin/clang",
            "cStandard": "${default}",
            "cppStandard": "${default}",
            "intelliSenseMode": "linux-clang-x64"
        }
    ],
    "version": 4
}

On MacOS (Macbook Pro M1), nothing of the above worked. I had only .hpp and .tpp file of the template class in my project, but creating main.cpp solved the issue.

I am using CMake Tools and this issue arose out of nowhere, I'm not exactly sure what I did that caused it, but I solved it in the following way:

I opened .vscode/c_cpp_properties.json, which somehow existed in my workspace even though I never created nor needed it, and added a configurationProvider key to my configuration with a value of ms-vscode.cmake-tools:

            "configurationProvider": "ms-vscode.cmake-tools"

All my include errors went away. It was clear to me that it was a CMake Tools issue within VS Code because compiling worked just fine and only those included files were affected that I either generated with CMake into my build directory (protobuf files) or that had to be included externally (with find_package).

If you don't have this file in your workspace, you can create it by clicking Edit "includePath" setting when you hover over the error squiggles and click Quick Fix.... It will be created for you.

Hope it helps anyone!

I had the same problem with including the path for the Eigen library. The following steps solved it:

1. Find the path for the package which VSCode is not able to detect. For example, let's say my Eigen folder is installed in /opt/homebrew/Celler/eigen/3.4.0_1/include/eigen3/Eigen.
2. open Command Palette.
3. type C/C++:Edit Configurations (JSON).
4. under "configurations": section, inside "includePath":, add the above folder address as another element in the list. It should now look like

Now save the file and restart VSCode.

I've solved for me.

You have to be sure install "C/C++ Extension" for VSCode and "Mysys". You can download and check install here

https://code.visualstudio.com/docs/languages/cpp#_example-install-mingwx64-on-windows

and configure your "c_cpp_properties.json" like this.

{
    "configurations": [
        {
            "name": "Win32",
            "includePath": [
                "${workspaceFolder}/**",
                "C:/msys64/ucrt64/include",
                "C:/msys64/ucrt64/lib/gcc/x86_64-w64-mingw32/13.1.0"
            ],
            "defines": [
                "_DEBUG",
                "UNICODE",
                "_UNICODE"
            ],
            "compilerPath": "C:/msys64/ucrt64/bin/gcc.exe",
            "intelliSenseMode": "gcc-x64",
            "configurationProvider": "ms-vscode.cpptools"
        }
    ],
    "version": 4
}

The important thing is add below path(s) in includePath

"C:/msys64/ucrt64/include"
"C:/msys64/ucrt64/lib/gcc/x86_64-w64-mingw32/13.1.0"

Apple M2 Pro, Sequoia 15.2

None of the above worked for me. I found the solution on the other IDE support site. The problem was in my broken developer tools.

Step 1.
It can fix the problem.

sudo xcode-select --switch /Library/Developer/CommandLineTools/

Step 2.
If it does not help, try to remove it

sudo rm -rf /Library/Developer/CommandLineTools

and install it again.

xcode-select --install

Errors relating to modern (C++20, C++23, ...) features

At the time of writing, C++20 and C++23 are the most recent standards. Recent compilers support most, if not all of C++20, and a significant number of C++23 features.

However, you may want to check if your default compiler version does support the features you are trying to use.

My guess would be that VS Code uses the default compiler installation to check for syntax errors, and include errors.

For example, in my specific case, I have set the -std=c++23 compiler flag in the VS Code settings.

However, the default compiler on my system is still gcc version 12.2.0. This is not the most up to date version. The reason is this is a Debian system, and the toolchains tend to lag a bit behind the alternatives, for example Ubuntu server systems.

I wanted to use the new std::format and std::println features of C++23.

I get include errors related to the include lines for these headers.

#include <format>
#include <print>

One way to fix this would be to install a more up-to-date compiler.

However, rather than risk breaking your system install, I would suggest considering an alternative solution.

Docker can provide quite a nice solution. It is relatively easy to build a Dockerfile and a Docker container image which contains the latest gcc and g++ compilers.

This will not fix your include errors - you will have to just ignore them - but it is a nice solution to get access to a new compiler without risking breaking other parts of your install.

It is also much easier than installing a second compiler chain. (Which if not done carefully can also break parts of your system.)

I won't give further details here, because it is too much a tangent to the original question.

In my case, the project builds successfully with CMake but VSCode shows errors in the include keyword because it's not able to find the headers.

I was thinking about manually setting the libraries in the includePath inside the .vscode/c_cpp_properties.json but I wanted to avoid thatas it will be pointing to some global cache path from conan.

The solution is that I tried to generate compilation database by adding this to the CMakeLists.txt:

# Generate compile_commands.json
set(CMAKE_EXPORT_COMPILE_COMMANDS ON)

and updated my .vscode/c_cpp_properties.json to use the generated compile commands:

{
  "configurations": [
    {
      // ...
      "compileCommands": "${workspaceFolder}/path_to_your_build/compile_commands.json"
    }
  ],
}

For Windows:

1. Please add this directory to your environment variable(Path):

C:\mingw-w64\x86_64-8.1.0-win32-seh-rt_v6-rev0\mingw64\bin\

2. For Include errors detected, mention the path of your include folder into

"includePath": [ "C:/mingw-w64/x86_64-8.1.0-win32-seh-rt_v6-rev0/mingw64/include/" ]

, as this is the path from where the compiler fetches the library to be included in your program.

In case you've copied and pasted code into your new file in VS Code

Please delete #include <iostream> and try to build again.