60

I'm trying to build a simple program that has multiple .cpp files. I'm using Visual Studio Code on Ubuntu 17.10 (Artful Aardvark) and using the GCC compiler.

Here's an example of what I've got (all the files are in the same folder):

main.cpp

#include "Cat.h"
int main() {
  speak();
  return 0;
}

Cat.h

#pragma once
void speak();

Cat.cpp

#include <iostream>
#include "Cat.h"
void speak() {
  std::cout << "Meow!!" << std::endl;
}

This simple program builds in both Code::Blocks and Visual Studio 2017 Community no problem, and I can't figure out what I need to do to make it run.

This error at the bottom indicates that the Cat.cpp file is not being picked up at all. If I was to drop the definition from this Cat.cpp file into the header file, the program compiles and runs fine, but I want to use that .cpp file.

I understand that I may need to tell Visual Studio Code where to look for the Cat.cpp file, but it's strange to me that it finds the header in the same location.

tasks.json

{
    // See https://go.microsoft.com/fwlink/?LinkId=733558
    // for the documentation about the tasks.json format
    "version": "2.0.0",
    "tasks": [
        {
            "label": "Build",
            "type": "shell",
            "command": "g++ -g /home/me/project/main.cpp -o Classes",
            "group": {
                "kind": "build",
                "isDefault": true,
            },
            "problemMatcher":"$gcc"
        }
    ]
}
Improve this question
1
  • I dont know anything about VS Code, but you definitely need to tell it to compile and link both CPP files into the executable. The header file is found because you reference it in main.cpp. Commented Dec 6, 2017 at 2:39

20 Answers 20

Reset to default
70

Add this in file tasks.json:

"label": "g++.exe build active file",
"args": [
    "-g",
    "${fileDirname}\\**.cpp",
    //"${fileDirname}\\**.h",
    "-o",
    "${fileDirname}\\${fileBasenameNoExtension}.exe",
],

And add this in file launch.json:

"preLaunchTask": "g++.exe build active file"

Then it will work if your sources are in separate folders.

Improve this answer
Sign up to request clarification or add additional context in comments.

12 Comments

It builds all files with .cpp name ending. The -o (outputfile) specifies what name the executable should have and where it should be located. For me on Linux the directory is called "workspaceFolder" i.e. "${workspaceFolder}/**.cpp"
@Anns98 when using "${fileDirname}\\**.cpp", gcc takes the **.cpp as literal and I get the error "(...)**.c: No such file or directory"
@Tiago for those having the same problem, you have to use a forward slash to select all .cpp files, like "${fileDirname}/**.cpp" instead of "${fileDirname}\\**.cpp"
no matter what i do , "${workspaceFolder}\\**.cpp", "${workspaceFolder}/**.cpp" or "${workspaceFolder}/*.cpp" Vs code take it literally and return the "No such file or directory" error. I test it with the Terminal directly and g++ build all files with no problem. I am using Ubuntu.
If you have spaces in folder names, it won't work, no matter what you do. That's because VS Code automatically adds quotation marks when folders have spaces. Removing all spaces from folder names made it work for me.. Hope it helps.
|
30

This is the tasks.json file for Visual Studio Code for Linux distributions, to compile multiple cpp files:

{
"version": "2.0.0",
"tasks": [
    {
        "type": "shell",
        "label": "C/C++: g++ build active file",
        "command": "/usr/bin/g++",
        "args": [
            "-g",
            "${fileDirname}/*.cpp",
            "-o",
            "${fileDirname}/${fileBasenameNoExtension}"
        ],
        "options": {
            "cwd": "/usr/bin"
        },
        "problemMatcher": [
            "$gcc"
        ],
        "group": {
            "kind": "build",
            "isDefault": true
        }
    }
]
}
Improve this answer

1 Comment

Thanks! I'm using an M1 Mac, and it started working after I switched the type from "cppbuild" to "shell".
15

This is a Windows answer for the same problem:

I was struggling with this as well until I found the following answer on Using GCC with MinGW:

You can modify your tasks.json to build multiple C++ files by using an argument like "${workspaceFolder}\\*.cpp" instead of ${file}. This will build all .cpp files in >your current folder. You can also modify the output filename by replacing "${fileDirname}\\${fileBasenameNoExtension}.exe" with a hard-coded filename (for >example "${workspaceFolder}\\myProgram.exe").

Note that the F in workspaceFolder is capitalized.

As an example, in my tasks.json file in my project, the text in between the brackets under "args" originally appeared as follows:

"-g",
  "${file}",
  "-o",
  "${fileDirname}\\${fileBasenameNoExtension}.exe"

This gave me reference errors because it was only compiling one and not both of my files.

However, I was able to get the program to work after changing that text to the following:

"-g",
"${workspaceFolder}\\*.cpp",
"-o",
"${fileDirname}\\${fileBasenameNoExtension}.exe"
Improve this answer

6 Comments

Is the `\` windows syntax?
@mLstudent33 Yes, that's windows escape syntax.
does this works for nested folders?. I've been trying to figure out a way to make it work for nested folders with something like ${workspaceFolder}\\**\\*.cpp
and then how would i run it?>
@APars Within Visual Studio Code, the shortcut to run programs is F5 (or Shift + F5 to skip debugging). Or you could use Ctrl + Shift + B to build the program.
|
7

If you have multiple files and one depends on a cpp file for another, you need to tell g++ to compile it as well, so the linker can find it. The simplest way would be:

g++ Cat.cpp main.cpp -o Classes

As a side note, you should probably compile with warnings, minimally -Wall, likely -Wextra, and possibly -Wpedantic, so you know if something you're doing is problematic.

Improve this answer

2 Comments

You suggest to add each file one by one? Seriously?
Well, you may call it simple. But it has nothing to do with the original question: the issue is how to tell VSCODE about the dependencies not g++
5

After finding a lot of solutions I find this only working, install the code runner extension. in settings, go to open settings in the right upper corner and simply paste this line in setting.json before the end of last closing bracket }

"code-runner.executorMap": {
    "cpp": "cd $dir && g++ *.cpp -o $fileNameWithoutExt && $dir$fileNameWithoutExt",
},

[settings.json --> file looks like] : https://i.sstatic.net/pUBYU.png

Improve this answer

1 Comment

BTW, The negative to this approach is you can no longer use a folder with multiple independent single source file programs. This sets code-runner to always assume each folder represents 1 executable. This is one reason why I don't recommend using code-runner with c or c++.
3

Use:

"tasks": [
    {
        "label": "echo",
        "type": "shell",
        "command": "g++",
        "args":[
            "-g","main.cpp","cat.cpp"
        ],
        "group": {
            "kind": "build",
            "isDefault": true
        }
    }

Just add cat.cpp in "args" and then try to run. It should run without error in Visual Studio Code.

Improve this answer

1 Comment

I guess that's one way to do it. Make sure he understands after adding the task, he will need to right-click on the file in the list to select "echo" to compile it.
2

For Mac you can use 

{
    "version": "2.0.0",
    "tasks": [
        {
            "type": "shell",
            "label": "shell: g++ build active file",
            "command": "/usr/bin/g++",
            "args": [
                "-g",
                "-Wall",
                "-Wextra",
                "-Wpedantic",
                "${workspaceFolder}/*/*.cpp",
                "${fileDirname}/*.cpp",
                "-o",
                "${fileDirname}/${fileBasenameNoExtension}"
            ],
            "options": {
                "cwd": "/usr/bin"
            },
            "problemMatcher": [
                "$gcc"
            ],
            "group": {
                "kind": "build",
                "isDefault": true
            }
        }
    ]
}

This will compile all the cpp file with all the directories which contain .cpp files.

Improve this answer

2 Comments

Thanks for the answer, could you please let me know how would I include the header files?
why cwd in /usr/bin? I'd not set it at all. why g++ - Apple provides clang, not GCC, g++, if present, is only wrapper.
2

On Windows / using Microsoft's msvc compiler the solution is

{
"version": "2.0.0",
"tasks": [
    {
        "type": "cppbuild",
        "label": "C/C++: cl.exe compila il file attivo",
        "command": "cl.exe",
        "args": [
            "/Zi",
            "/EHsc",
            "/nologo",
            "/Fe:",
            "${fileDirname}\\${fileBasenameNoExtension}.exe",
            "*.c"
        ],
        "options": {
            "cwd": "${workspaceFolder}"
        },
        "problemMatcher": [
            "$msCompile"
        ],
        "group": {
            "kind": "build",
            "isDefault": true
        },
        "detail": "compilatore: cl.exe"
    }
]

}

Improve this answer

Comments

1

If you are using linux then know how to use make. If save a lot of time and effort. If you have even 10s or 100s of files and some dependencies are there then just make a Makefile once and every time you compile just use one command make and that will do all the work for you. Even you can make a keyboard shortcut for that command in VSCode.

Check out here to use make and here for using that in VSCode.

Improve this answer

Comments

1

credits: Anns98.

Remember below args are belongs to g++.10.2.0 C++17.

You should tweak your compiler implicitly/explicitly to achieve the consistency you desire.

CHECKOUT: winlibs (gcc-10.2.0-llvm-11.0.0-mingw-w64-8.0.0-r5) looks promising.

{
  "version": "2.0.0",
  "tasks": [
    {
      "type": "cppbuild",
      "label": "retr0C++",
      "command": "C:\\mingw64\\bin\\g++",
      "args": [
        "-std=c++17",
        "-I",
        "${fileDirname}\\includes",
        "-o",
        "${fileDirname}\\${fileBasenameNoExtension}.exe",
        "-g",
        //"${file}",
        "${fileDirname}\\**.cpp"
      ],
      "options": {
        "cwd": "C:\\mingw64\\bin"
      },
      "problemMatcher": ["$gcc"],
      "group": {
        "kind": "build",
        "isDefault": true
      },
      "detail": "compiler: C:\\mingw64\\bin\\g++"
    }
  ]
}
Improve this answer

Comments

1

As I understand, your program 24_-_Classes architecture just shows like:

24_-_Classes

|

|_.vscode

|     |__c_cpp_properties.json

|     |__launch.json

|     |__settings.json

|     |__tasks.json

|__cat.cpp

|__cat.h

|__main.cpp

Bro, I know what you mean "I understand that I may need to tell VS Code where to look for the Cat.cpp file but it's strange to me that it finds the header in the same location. ".

c_cpp_properties.json: allows you to change settings such as the path to

the compiler, include paths.

As your project architecture shows, your include file is located in the same directory of your source files.

So your c_cpp_properties.json should be looks like:

{
  "configurations": [
    {
      "name": "Mac",
      "includePath": [
        // This is the include files directory
        "${workspaceFolder}/**", // Have Change
        "/Library/Developer/CommandLineTools/usr/include",
        "/Library/Developer/CommandLineTools/usr/lib/clang/9.0.0/include",
        "/usr/local/include",
        "/Library/Developer/CommandLineTools/usr/include/c++/v1",
        "/usr/include"
      ],
      "defines": [],
      "macFrameworkPath": [
        "/System/Library/Frameworks",
        "/Library/Developer/CommandLineTools/SDKs/MacOSX.sdk/System/Library/Frameworks",
        "/Library/Frameworks"
      ],
      "compilerPath": "/usr/bin/clang",
      "cStandard": "c11",
      "cppStandard": "c++11",
      "intelliSenseMode": "clang-x64"
    }
  ],
  "version": 4
}

Notice that line ""${workspaceFolder}/**", // Have Change", as my

comment"// This is the include files directory" shows, change your

""${workspaceRoot}"," to my ""${workspaceFolder}/**".(This is used to add include file directory.)

Change this configuration to your needed Linux. E.g:

{
  "configurations": [
    {
      "name": "Linux",
      "includePath": [
        // This line is to add include file directory.
        "${workspaceFolder}/**" //Needed to Notices!
        "/usr/include/c++/7",
        "/usr/include/x86_64-linux-gnu/c++/7",
        "/usr/include/c++/7/backward",
        "/usr/lib/gcc/x86_64-linux-gnu/7/include",
        "/usr/local/include",
        "/usr/lib/gcc/x86_64-linux-gnu/7/include-fixed",
        "/usr/include/x86_64-linux-gnu",
        "/usr/include",
      ],
      "defines": [],
      "compilerPath": "/usr/bin/gcc",
      "cStandard": "c11",
      "cppStandard": "c++17",
      "intelliSenseMode": "clang-x64"
    }
  ],
  "version": 4
}

There is no need to add that lines:

"/home/danny/Documents/C++_Projects/24_-_Classes/Cat.cpp",
"/home/danny/Documents/C++_Projects/24_-_Classes/",
"/home/danny/Documents/C++_Projects/24_-_Classes/.vscode",
"/home/danny/Documents/C++_Projects/24_-_Classes/.vscode/Cat.cpp"

And I also know what your want to know"At one point I wondered if I need to add a double command in there to tell the compiler to build both .cpp files in the tasks.json",

Your tasks.json just looks like:

{
  "version": "2.0.0",
  "tasks": [
    {
      "type": "shell",
      "label": "Compile With clang++",
      //"command": "clang++",/usr/bin/clang++
      "command": "/usr/bin/clang++",
      "args": [
        "-std=c++11",
        "-stdlib=libc++",
        // My project fitBodyBootCamp were under 
        // /Users/marryme/VSCode/CppProject/fitBodyBootCamp
        // So ${workspcaeFolder} also were
        // /Users/marryme/VSCode/CppProject/fitBodyBootCamp
        // all the *.cpp files were under
        // /Users/marryme/VSCode/CppProject/fitBodyBootCamp
        "${workspaceFolder}/*.cpp", // Have changed
        "-o",
        // Thanks those chiense website bloggers!
        // 1.mac vscode compile c++ multi-directory code demo
        // https://blog.csdn.net/fangfengzhen115/article/details/121496770?utm_medium=distribute.pc_relevant.none-task-blog-2~default~baidujs_baidulandingword~default-4.pc_relevant_default&spm=1001.2101.3001.4242.3&utm_relevant_index=7
        // 2.Compile and debug c++ multi-folder project under VSCode (non-makefile)
        // https://blog.csdn.net/BaiRuichang/article/details/106463035
        // I also put the main.o under my current workspace directory
        // This after "-o"  is the target file test.o or test.out or test
        "${workspaceFolder}/${fileBasenameNoExtension}", // Have changed
        "-I",
        // This after "-I" if the include files directory
        "${workspaceFolder}", // Have changed
        "-Wall",
        "-g"
      ],
      "options": {
        // "cwd" is the source files directory
        "cwd": "${workspaceFolder}" // Have changed
      },
      "group": {
        "kind": "build",
        "isDefault": true
      }
    }
  ]
}

That line I add a comment "//Have changed" that's what you need to notice.

Notices: your source files are not only, that are multiple sources.

So, just use using an argument like "${workspaceFolder}/*.cpp" instead of ${file}.

Also, just use using an argument like "${workspaceFolder}/${fileBasenameNoExtension}" instead of "${fileDirname}/${fileBasenameNoExtension}".

Change this configuration to your needed Linux, e.g:

{
  "version": "2.0.0",
  "tasks": [
    {
      "type": "shell",
      "label": "g++ build active file",
      "command": "/usr/bin/g++",
      "args": [
        "-g", 
        "${workspaceFolder}/*.cpp", // Need to change!
        "-o", 
        "${workspaceFolder}/${fileBasenameNoExtension}" // Need to change!
      ],

      "options": {
        // If This not work, just change to ""cwd": "${workspaceFolder}""
        "cwd": "/usr/bin" //I do not if change in Linux!
      },
      "problemMatcher": ["$gcc"],
      "group": {
        "kind": "build",
        "isDefault": true
      }
    }
  ]
}

And your launch.json just looks like:

{
  // Use IntelliSense to learn about possible attributes.
  // Hover to view descriptions of existing attributes.
  // For more information, visit: https://go.microsoft.com/fwlink/?linkid=830387
  "version": "0.2.0",
  "configurations": [
    {
      "name": "Debug With LLDB",
      "type": "lldb",
      "request": "launch",
      // "program" is the target file diretory
      "program": "${workspaceFolder}/${fileBasenameNoExtension}", // Have changed
      "args": [],
      "stopAtEntry": true,
      //"cwd": "${workspaceFolder}/../build",// Have changed
      //"cwd": "${fileDirName}", ${workspaceFolder}/../build
      // Changes the current working directory directive ("cwd") to the folder
      // where main.cpp is.
      // This "cwd" is the same as "cwd" in the tasks.json 
      // That's the source files directory
      "cwd": "${workspaceFolder}", // Have changed
      "environment": [],
      "externalConsole": false,
      "preLaunchTask": "Compile With clang++"
    }
  ]
}

Change this configuration to your needed Linux, e.g:

{
  "version": "0.2.0",
  "configurations": [
    {
      "name": "g++ build and debug active file",
      "type": "cppdbg",
      "request": "launch",
      // "program" is the target file diretory
      "program": "${workspaceFolder}/${fileBasenameNoExtension}", // Have changed
      "args": [],
      "stopAtEntry": false,
      // That's the source files directory
      "cwd": "${workspaceFolder}", // Notices!!!
      "environment": [],
      "externalConsole": false,
      "MIMode": "gdb",
      "setupCommands": [
        {
          "description": "Enable pretty-printing for gdb",
          "text": "-enable-pretty-printing",
          "ignoreFailures": true
        }
      ],
      "preLaunchTask": "g++ build active file",
      "miDebuggerPath": "/usr/bin/gdb"
    }
  ]
}

If you are using Code-Runner to run your project, settings.json looks like:

{
    "files.defaultLanguage": "c++",
    "editor.suggest.snippetsPreventQuickSuggestions": false,
    "editor.acceptSuggestionOnEnter": "off",
    "code-runner.runInTerminal": true,
    "code-runner.executorMap": {
        // 0.Only One Simple C/C++ file build, compile, debug...
        //"c": "cd $dir && gcc -std=c11 -stdlib=libc++  $fileName  -o $fileNameWithoutExt && $dir$fileNameWithoutExt",
        //"cpp": "cd $dir && g++ -std=c++11 -stdlib=libc++ $fileName -o $fileNameWithoutExt && $dir$fileNameWithoutExt"
        //"c": "cd $dir && make  && ./fileNameWithoutExt && make clean",
        //"cpp": "cd $dir && make && ./fileNmaeWithoutExt && make clean"
        // "c": "cd $dir && make main  && ../build/main && make clean",
        // "cpp": "cd $dir && make main && ../build/main && make clean"
        // 1.0 Reference
        // Thanks chinese website blogger!
        // (Configure multiple c file compilation with vscode on Mac os)
        // https://blog.csdn.net/songjun007/article/details/117641162
        //"c": "cd $dir && gcc -std=c11 -stdlib=libc++  -I ${workspaceFolder}/inc ${workspaceFolder}/*.c  -o ${workspaceFolder}/build/${fileBasenameNoExtension} && $dir$fileNameWithoutExt",
        //"cpp": "cd $dir && g++ -std=c++11 -stdlib=libc++ -I ${workspaceFolder}/inc ${workspaceFolder}/*.cpp -o ${workspaceFolder}/build/${fileBasenameNoExtension} && $dir$fileNameWithoutExt"
        // 1.1Use gcc or g++
        // "c": "cd $dir && gcc -std=c11 -stdlib=libc++  $dir/../src/*.c  -o $dir/../build/$fileNameWithoutExt && $dir/../build/$fileNameWithoutExt",
        //"cpp": "cd $dir && g++ -std=c++11 -stdlib=libc++  $dir/../src/*.cpp -o $dir/../build/$fileNameWithoutExt && $dir/../build/$fileNameWithoutExt"
        //
        // clang -g /Users/marryme/VSCode/CppProject/fitBody/src/bank.cpp /Users/marryme/VSCode/CppProject/fitBody/src/main.cpp -o /Users/marryme/VSCode/CppProject/fitBody/build/main
        // 1.2Use clang or clang++ 
        //"c": "cd $dir && clang -std=c11 -stdlib=libc++  $dir/../src/*.c  -o $dir/../build/$fileNameWithoutExt && $dir/../build/$fileNameWithoutExt",
        //"cpp": "cd $dir && clang++ -std=c++11 -stdlib=libc++  $dir/../src/*.cpp -o $dir/../build/$fileNameWithoutExt && $dir/../build/$fileNameWithoutExt"
        // 2.Seprated multiple sourece C/C++ files under different folder build, compile, debug...
        // if put main.o and debug folder into new directory ./build/
        //"c": "cd $dir && clang -std=c11 -stdlib=libc++  $dir/*.c  -o $dir/../build/$fileNameWithoutExt && $dir/../build/$fileNameWithoutExt",
        //"cpp": "cd $dir && clang++ -std=c++11 -stdlib=libc++  $dir/*.cpp -o $dir/../build/$fileNameWithoutExt && $dir/../build/$fileNameWithoutExt"
        // 3.Mutiple sourece C/C++ files under same folder build, compile, debug...
        // if put main.o and debug folder into the current directory "./"
        "c": "cd $dir && clang -std=c11 -stdlib=libc++  $dir/*.c  -o $dir/$fileNameWithoutExt && $dir/$fileNameWithoutExt", // Have changed
        "cpp": "cd $dir && clang++ -std=c++11 -stdlib=libc++  $dir/*.cpp -o $dir/$fileNameWithoutExt && $dir/$fileNameWithoutExt" // Have changed
},
    "code-runner.saveFileBeforeRun": true,
    "code-runner.preserveFocus": false,
    "code-runner.clearPreviousOutput": false,
    "code-runner.ignoreSelection": true,
    "C_Cpp.clang_format_sortIncludes": true,
    "editor.formatOnType": true,
    "clang.cxxflags": [
        "-std=c++11"
    ],
    "clang.cflags": [
        "-std=c11"
    ],
    "C_Cpp.updateChannel": "Insiders",
    "[makefile]": {
        "editor.insertSpaces": true
    },
    "C_Cpp.default.includePath": [
        "${workspaceFolder}"
],
"clang.completion.enable": true

}

Change this configuration to your needed Linux, that may be like:

{
    "files.defaultLanguage": "c++",
    "editor.suggest.snippetsPreventQuickSuggestions": false,
    "editor.acceptSuggestionOnEnter": "off",
    "code-runner.runInTerminal": true,
    "code-runner.executorMap": {
       "c": "cd $dir && gcc -std=c11 -stdlib=libc++  $dir/*.c  -o $dir/$fileNameWithoutExt && $dir/$fileNameWithoutExt", // Have changed
       "cpp": "cd $dir && g++ -std=c++11 -stdlib=libc++  $dir/*.cpp -o $dir/$fileNameWithoutExt && $dir/$fileNameWithoutExt" // Have changed
    },
    "code-runner.saveFileBeforeRun": true,
    "code-runner.preserveFocus": false,
    "code-runner.clearPreviousOutput": false,
    "code-runner.ignoreSelection": true,
    "C_Cpp.clang_format_sortIncludes": true,
    "editor.formatOnType": true,
    "clang.cxxflags": [
        "-std=c++11"
    ],
    "clang.cflags": [
        "-std=c11"
    ],
    "C_Cpp.updateChannel": "Insiders",
    "C_Cpp.default.includePath": [
        "${workspaceFolder}"
    ],
    "clang.completion.enable": true
}

But I suggest that you may read Using C++ on Linux in VS Code.

END.

Improve this answer

Comments

1

Open your tasks.json file and put the following in it:

{
"version": "2.0.0",
"tasks": [
    {
        "type": "shell",
        "label": "C/C++: g++ build active file",
        "command": "/usr/bin/g++",
        "args": [
            "-g",
            "${workspaceFolder}/*.c",
            "${workspaceFolder}/*.h",
            "-o",
            "${fileDirname}/${fileBasenameNoExtension}"
        ],
        "options": {
            "cwd": "/usr/bin"
        },
        "problemMatcher": [
            "$gcc"
        ],
        "group": "build"
    },
    {
        "type": "cppbuild",
        "label": "C/C++: gcc-8 build active file",
        "command": "/usr/bin/gcc-8",
        "args": [
            "-fdiagnostics-color=always",
            "-g",
            "${workspaceFolder}/*.c",
            "${workspaceFolder}/*.h",
            "-o",
            "${fileDirname}/${fileBasenameNoExtension}"
        ],
        "options": {
            "cwd": "${fileDirname}"
        },
        "problemMatcher": [
            "$gcc"
        ],
        "group": {
            "kind": "build",
            "isDefault": true
        },
        "detail": "Task generated by Debugger."
    }
]
}

If you have any C++ source, add "${workspaceFolder}/*.cpp" too. Note that if you haven't any of those files in your dir it gives you an error.

Improve this answer

Comments

1

'Adds single quotes'

I also had this problem on linux, and arrived at this solution based on some other answers and comments here.

Replacing the args parameter "${file}" in tasks.json with "${fileDirname}/*.cpp" will work for some of us - but only if there are no spaces in the resulting path string.

However, I have spaces in some of the directory names on the path to my working directory. So, when I use ${fileDirname} to get the directory string, there are spaces in the result.

The presence of spaces means this argument will automatically be surrounded in double quotes, becoming a literal string and also destroying our expected behaviour of the asterisk wildcard *. The compiler will simply be looking for a single file named *.cpp in that directory.

A set of single quotes around the relevant portion of the argument solves the problem (and I won't need to go removing all the spaces from my existing directory names).

And so: the argument "${fileDirname}/*.cpp" gains some single quotes and becomes "'${fileDirname}'/*.cpp" and everything works as expected.

tasks.json
{
  "tasks": [
    {
      "type": "cppbuild",
      "label": "C/C++: g++ build active file",
      "command": "/usr/bin/g++",
      "args": [
        "-g",
        "'${fileDirname}'/*.cpp", // note the placement of the single quotes
        "-o",
        "${fileDirname}/${fileBasenameNoExtension}"
      ],
      // ... other json blocks ... 
    }
  ]
}
Improve this answer

1 Comment

The single quote was the only thing that worked for me (I have spaces in my path name - iCloud Drive). Thanks.
1

For those who are struggling with not working syntax like ${workspaceFolder}\**.cpp, ${workspaceFolder}/**.cpp, ${workspaceFolder}/*.cpp, etc., be sure to check also other parameters in tasks.json.
On my ArchLinux with VS Code 1.74.2, setting "type": "cppbuild" helped. So, my tasks.json looks like this:

{
    "version": "2.0.0",
    "tasks": [
        {
            // "type": "cppbuild",      // Not working if commented out
            "type": "cppbuild",         // OK
            "label": "Build with Clang++ (Linux)",
            "command": "clang++",
            "args": [
                "-std=c++17",
                "${fileDirname}/*.cpp",
                "-o",                
                "${fileDirname}/${fileBasenameNoExtension}",
            ],
            "options": {
                "cwd": "${fileDirname}"
            },
            "group": {
                "kind": "build",
                "isDefault": true
            },
        },
    ]
}

It seems that VS Code wraps arguments in quotes for several reasons, also mentioned by others.

Improve this answer

Comments

1

On the terminal tab of your Visual Studio Code program, write the following:

g++ nameOne.cpp nameTwo.cpp -o a.out
./a.out
Improve this answer

Comments

0

I had similar problem, and it was not easy to find answer which I fully understand. First thing you need to understand is that all .cpp files used in your project need to be compiled for the linker. for project with one .cpp file there is relatively no issue. you simply need to tell g++ which .cpp file need to be compiled by running the following command in the terminal from the root directory:

g++ -g main.cpp -o mainApp

This tells g++ to compile main.cpp an create a consolApp (output file) named mainApp.

  1. In the case of a project with more than one .cpp file,

|--root

  • |--main.cpp}
  • |--include1
    • |-- foo1.h
    • |-- foo1.cpp
  • |-- include2
    • |-- foo2.h
    • |-- foo2.cpp
  • |-- foo3.cpp

To compile this project and build the output file we run this in the terminal:

g++ -g main.cpp include1/foo1.cpp include2/foo2.cpp foo3.cpp -o mainApp

Note that the order in which we pass the .cpp files to be compiled doesn't really matter.

  1. You can already understand that for a very large project writing that command will be very tedious. you can rewrite is as follow

    g++ -g ./*.cpp include1/*.cpp include2/*.cpp -o mainApp

This simply tells g++ to compile all .cpp file in the root, include1 and include2 folders.

  1. What if your project has a lot of folders, you can simply run it recursively

    g++ -g ./**/*.cpp -o mainApp

This is kind of telling g++ to go through root folder and through other folder and compile all .cpp files it will find.

  1. To do the same thing in vscode, go to the tasks.json file, and in 'args' add :

    "${workspaceFolder}/.cpp",
    "${workspaceFolder}/**/    .cpp",

This is the equivalent of :

g++ -g ./**/*.cpp -o mainApp
Improve this answer

Comments

0

I had trouble to getting VS Code to compile multiple source files. It turned out to be that the workspace folder file path had a folder with a space in it. That space would cause the changed line to be read literally instead of looking for all .cpp files. I changed the path to have no spaces, and then it compiled successfully.

I only had to change one line in the tasks.json file:

{
"version": "2.0.0",
"tasks": [
    {
        "type": "cppbuild",
        "label": "C/C++: g++ build active file",
        "command": "/usr/bin/g++",
        "args": [
            "-fdiagnostics-color=always",
            "-g",
            "${workspaceFolder}/*.cpp", //changed line from "${file}",
            "-o",
            "${fileDirname}/${fileBasenameNoExtension}"
        ],
        "options": {
            "cwd": "${fileDirname}"
        },
        "problemMatcher": [
            "$gcc"
        ],
        "group": "build",
        "detail": "compiler: /usr/bin/g++"
    }
]

}

Improve this answer

Comments

0

Use vs code c/c++ runner extension with CodeLLDB and Microsoft C/C++ extensions. it worked for me in windows OS.

Improve this answer

Comments

0

this task worked for me on Ubuntu

{
   "tasks": [
      {
         "type": "cppbuild",
         "label": "C/C++: g++ build active file",
         "command": "/usr/bin/g++",
         
         "args": [
            "-fdiagnostics-color=always",
            "-g",
            "${fileDirname}/*.cpp",
            "-o",
            "${fileDirname}/${fileBasenameNoExtension}"
         ],
         "options": {
            "cwd": "/usr/bin"
         },
         "problemMatcher": [
            "$gcc"
         ],
         "group": {
            "kind": "build",
            "isDefault": true
         },
         "detail": "Build executable for cpp."
      },
   ],
   "version": "2.0.0"
}

the launch.json is

{
  "version": "0.2.0",
  "configurations": [
    {
      "name": "C/C++ Runner: Debug Session",
      "type": "cppdbg",
      "request": "launch",
      "args": [],
      "stopAtEntry": false,
      "externalConsole": false,
      "cwd": "${fileDirname}",
      "program": "${fileDirname}/${fileBasenameNoExtension}",
      "MIMode": "gdb",
      "miDebuggerPath": "gdb",
      "setupCommands": [
        {
          "description": "Enable pretty-printing for gdb",
          "text": "-enable-pretty-printing",
          "ignoreFailures": true
        }
      ],
      "preLaunchTask": "C/C++: g++ build active file",
      // "postDebugTask": "delete executable"
    },
    ],
}
Improve this answer

Comments

0

I tried using many options like "${workspaceFolder}\*.cpp", "${workspaceFolder}/*.cpp", "${workspaceFolder}/**.cpp" and even "'${workspaceFolder}'\*.cpp", etc. but nothing worked. I kept on getting error like cc1plus: fatal error: /testcode/*.cpp: No such file or directory kept repeating.

Finally, I realised the change that needed to fix this issue. The "type" should have value as "shell" and not "cppbuild" in tasks.json.

{
  "tasks": [
    {
      "type": "shell",    //"cppbuild" did not work.
      "label": "C/C++: g++-11 build active file",
      "command": "/usr/bin/g++-11",
      "args": [
        "-fdiagnostics-color=always",
        "-g",
        "${workspaceFolder}/*.cpp",
        "-o",
        "${fileDirname}/${fileBasenameNoExtension}"
      ],
      "options": {
        "cwd": "${fileDirname}"
      },
      "problemMatcher": [
        "$gcc"
      ],
      "group": {
        "kind": "build",
        "isDefault": true
      },
      "detail": "Task generated by Debugger."
    }
  ],
  "version": "2.0.0"
}
Improve this answer

1 Comment

FYI: if you're on version 19.4 of cpptools (which I reckon you are), you should actually be reading VS Code C/C++ (1.19.4) cppbuild task does not support globbing when args is an array. Why?

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.

Start asking to get answers

Find the answer to your question by asking.

Ask question

Explore related questions

See similar questions with these tags.