How to Include Compiler Flags in Visual Studio Code

Visual Studio Code: how to add arguments for g++ compiler?

Here is my solution to this predicament. I link it with my projects Makefile.

First, you'll need to build a Makefile, if your using GCC using a Makefile on its own is... controversial to say the least. But I think it serves the purposes of this example. As you may know, running "make" instead of g++ in the current directory will parse the Makefile and run the corresponding commands. But in your case, your Makefile may look similar to:

#You're gonna wanna make it think that your executable doesnt exist, otherwise,
#because the executable exists, make will assume its the most recent build.
.PHONY: debug 

#using g++ and the flags inline like this, is generally seen as bad practice, it might be worth
#looking into using Makefiles to make this more acceptable, but this will get you started.
debug:
    g++ -g -o debug main.cpp -std=c++17

clean:
    rm debug
#if you copy this exactly, make you you replace the spaces with proper tab
#characters otherwise it will error out.

The Juicy part is in VS code; It has a very power feature known as tasks. Tasks are their very own special rabbit hole, but to put it bluntly, you add a task to the "tasks" array in a generated tasks.json file in your workspace, if you're not familar with how that might look, here is the syntax for a task:

    {
        "label": "[name of task]",
        "type": "[type of task, usually its a shell command]",
        "command": "[the actual command to call]"
    }

There are many more features that tasks can offer, but for making a build tool this will be all you need, for me, this resulted in a file that looked like this:

{
// See https://go.microsoft.com/fwlink/?LinkId=733558
// for the documentation about the tasks.json format
"version": "2.0.0",
"tasks": [
    {
        "label": "build_debug",
        "type": "shell",
        "command": "make"
    },
    {
        "label": "clean",
        "type": "shell",
        "command": "make clean"
    },
    {
        "label": "build",
        "dependsOn": [
            "clean",
            "build_debug"
        ],
        "problemMatcher": [
            "$gcc"
        ]
    }
]
}

Why do we need to have a final build call? because your launch.json object can take a "preLaunchTask" that will automatically call prior to debug. You can slap in that final build call, and it will compile, debugger, and then run your app. it will even integrate GDB breakpoints and memory tracking into the workspace. My launch.json looks like this:

{
// 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": "(gdb) Launch",
        "type": "cppdbg",
        "request": "launch",
        "program": "${workspaceFolder}/runnable",
        "args": [],
        "stopAtEntry": false,
        "cwd": "${workspaceFolder}",
        "environment": [],
        "externalConsole": false,
        "MIMode": "gdb",
        "preLaunchTask": "build",
        "setupCommands": [
            {
                "description": "Enable pretty-printing for gdb",
                "text": "-enable-pretty-printing",
                "ignoreFailures": false
            }
        ]
    }
]
}

Sorry for the long replay, i hope it helps :)

CMake: add conditional compiler flags into Visual Studio project

You can use CMAKE_CXX_COMPILER_ID and CMAKE_CXX_SIMULATE_ID with your favourite way of handling compilers (if-else or generator expressions)

Output for -T ClangCL (Visual Studio 2019):

message(STATUS ${CMAKE_CXX_COMPILER_ID}) // Clang
message(STATUS ${CMAKE_CXX_SIMULATE_ID}) // MSVC

Output with no toolkit (Visual Studio 2019):

message(STATUS ${CMAKE_CXX_COMPILER_ID}) // MSVC
message(STATUS ${CMAKE_CXX_SIMULATE_ID}) // <empty>

Is there an analog to Compiler Flags from Code Blocks in Visual Studio?

I have been digging around a little more, and found an answer here.

Since the purpose of the addition of the flag was to enable the option to stop the console from appearing, this solution is sufficient.

---

Related Topics