¿Cómo configuro Visual Studio Code para compilar código C ++?

El editor de código Visual Studio de Microsoft es bastante bueno, pero no tiene soporte predeterminado para construir proyectos C ++.

¿Cómo lo configuro para hacer esto?

Hay una forma mucho más fácil de compilar y ejecutar código C ++, no se necesita configuración:

1. Instalar la extensión Code Runner
2. Abra su archivo de código C ++ en el Editor de texto, luego use el acceso directo Ctrl+Alt+N, o presione F1y luego seleccione / escriba Run Code, o haga clic derecho en el Editor de texto y luego haga clic Run Codeen el menú contextual, el código se compilará y ejecutará, y la salida se mostrará en el Ventana de salida.

Además, puede actualizar la configuración en settings.json usando diferentes compiladores de C ++ como desee, la configuración predeterminada para C ++ es la siguiente:

"code-runner.executorMap": {
    "cpp": "g++ $fullFileName && ./a.out"
}

Las tareas de construcción son específicas del proyecto. Para crear un nuevo proyecto, abra un directorio en Visual Studio Code.

Siguiendo las instrucciones aquí , presione Ctrl+ Shift+ P, escriba Configure Tasks, selecciónelo y presione Enter.

Se abrirá el archivo tasks.json. Pegue el siguiente script de compilación en el archivo y guárdelo:

{
    "version": "0.1.0",
    "command": "make",
    "isShellCommand": true,
    "tasks": [
        {
            "taskName": "Makefile",

            // Make this the default build command.
            "isBuildCommand": true,

            // Show the output window only if unrecognized errors occur.
            "showOutput": "always",

            // Pass 'all' as the build target
            "args": ["all"],

            // Use the standard less compilation problem matcher.
            "problemMatcher": {
                "owner": "cpp",
                "fileLocation": ["relative", "${workspaceRoot}"],
                "pattern": {
                    "regexp": "^(.*):(\\d+):(\\d+):\\s+(warning|error):\\s+(.*)$",
                    "file": 1,
                    "line": 2,
                    "column": 3,
                    "severity": 4,
                    "message": 5
                }
            }
        }
    ]
}

Ahora vaya al menú Archivo → Preferencias → Atajos de teclado y agregue la siguiente combinación de teclas para la tarea de compilación:

// Place your key bindings in this file to overwrite the defaults
[
    { "key": "f8",          "command": "workbench.action.tasks.build" }
]

Ahora, cuando presione F8, se ejecutará el archivo Makefile y los errores se subrayarán en el editor.

Un ejemplo de tarea de archivo MAKE para la nueva versión 2.0.0 tasks.json.

En el fragmento de abajo, algunos comentarios espero que sean de utilidad.

{
    "version": "2.0.0",
    "tasks": [
        {
            "label": "<TASK_NAME>",
            "type": "shell",
            "command": "make",
            // use options.cwd property if the Makefile is not in the project root ${workspaceRoot} dir
            "options": {
                "cwd": "${workspaceRoot}/<DIR_WITH_MAKEFILE>"
            },
            // start the build without prompting for task selection, use "group": "build" otherwise
            "group": {
                "kind": "build",
                "isDefault": true
            },
            "presentation": {
                "echo": true,
                "reveal": "always",
                "focus": false,
                "panel": "shared"
            },
            // arg passing example: in this case is executed make QUIET=0
            "args": ["QUIET=0"],
            // Use the standard less compilation problem matcher.
            "problemMatcher": {
                "owner": "cpp",
                "fileLocation": ["absolute"],
                "pattern": {
                    "regexp": "^(.*):(\\d+):(\\d+):\\s+(warning|error):\\s+(.*)$",
                    "file": 1,
                    "line": 2,
                    "column": 3,
                    "severity": 4,
                    "message": 5
                }
            }
        }
    ]
}

Así es como configuré mi VS para C ++

Asegúrese de cambiar las rutas adecuadas a donde se instaló su MinGW

launch.json

{
   "version": "0.2.0",
   "configurations": [
       {
           "name": "C++ Launch (GDB)",                
           "type": "cppdbg",                         
           "request": "launch",                        
           "targetArchitecture": "x86",                
           "program": "${workspaceRoot}\\${fileBasename}.exe",                 
           "miDebuggerPath":"C:\\mingw-w64\\bin\\gdb.exe", 
           "args": [],     
           "stopAtEntry": false,                  
           "cwd": "${workspaceRoot}",                  
           "externalConsole": true,                  
           "preLaunchTask": "g++"　　                  
           }
   ]
}

tasks.json

{
    "version": "0.1.0",
    "command": "g++",
    "args": ["-g","-std=c++11","${file}","-o","${workspaceRoot}\\${fileBasename}.exe"],
    "problemMatcher": {
        "owner": "cpp",
        "fileLocation": ["relative", "${workspaceRoot}"],
        "pattern": {
            "regexp": "^(.*):(\\d+):(\\d+):\\s+(warning|error):\\s+(.*)$",
            "file": 1,
            "line": 2,
            "column": 3,
            "severity": 4,
            "message": 5
        }
    }
}

c_cpp_properties.json

{
    "configurations": [
        {
            "name": "Win32",
            "includePath": [
                "${workspaceRoot}",
                "C:/mingw-w64/lib/gcc/x86_64-w64-mingw32/7.2.0/include/c++",
                "C:/mingw-w64/lib/gcc/x86_64-w64-mingw32/7.2.0/include/c++/x86_64-w64-mingw32",
                "C:/mingw-w64/lib/gcc/x86_64-w64-mingw32/7.2.0/include/c++/backward",
                "C:/mingw-w64/lib/gcc/x86_64-w64-mingw32/7.2.0/include",
                "C:/mingw-w64/lib/gcc/x86_64-w64-mingw32/7.2.0/include/c++/tr1",
                "C:/mingw-w64/x86_64-w64-mingw32/include"
            ],
            "defines": [
                "_DEBUG",
                "UNICODE",
                "__GNUC__=6",
                "__cdecl=__attribute__((__cdecl__))"
            ],
            "intelliSenseMode": "msvc-x64",
            "browse": {
                "path": [
                    "${workspaceRoot}",
                    "C:/mingw-w64/lib/gcc/x86_64-w64-mingw32/7.2.0/include/c++",
                    "C:/mingw-w64/lib/gcc/x86_64-w64-mingw32/7.2.0/include/c++/x86_64-w64-mingw32",
                    "C:/mingw-w64/lib/gcc/x86_64-w64-mingw32/7.2.0/include/c++/backward",
                    "C:/mingw-w64/lib/gcc/x86_64-w64-mingw32/7.2.0/include",
                    "C:/mingw-w64/lib/gcc/x86_64-w64-mingw32/7.2.0/include/c++/tr1",
                    "C:/mingw-w64/x86_64-w64-mingw32/include"
                ]
            },
            "limitSymbolsToIncludedHeaders": true,
            "databaseFilename": ""
        }
    ],
    "version": 3
}

Referencia:

1. C / C ++ para VS Code

2. plantilla c_cpp_properties.json

Para construir / ejecutar proyectos C ++ en código VS, debe configurar manualmente el archivo tasks.json que se encuentra en la carpeta .vscode en la carpeta del área de trabajo. Para abrir tasks.json , presione ctrl + shift + P , y escriba Configurar tareas , y presione enter , lo llevará a tasks.json

Aquí proporciono mi archivo tasks.json con algunos comentarios para que el archivo sea más comprensible, se puede usar como referencia para configurar tasks.json , espero que sea útil

tasks.json

{
    "version": "2.0.0",

    "tasks": [

        {
            "label": "build & run",     //It's name of the task , you can have several tasks 
            "type": "shell",    //type can be either 'shell' or 'process' , more details will be given below
            "command": "g++",   
            "args": [
                "-g",   //gnu debugging flag , only necessary if you want to perform debugging on file  
                "${file}",  //${file} gives full path of the file
                "-o",   
                "${workspaceFolder}\\build\\${fileBasenameNoExtension}",    //output file name
                "&&",   //to join building and running of the file
                "${workspaceFolder}\\build\\${fileBasenameNoExtension}"
            ],
            "group": {
                "kind": "build",    //defines to which group the task belongs
                "isDefault": true
            },
            "presentation": {   //Explained in detail below
                "echo": false,
                "reveal": "always",
                "focus": true,
                "panel": "shared",
                "clear": false,
                "showReuseMessage": false
            },
            "problemMatcher": "$gcc"
        },

    ]
}

Ahora, indicando directamente desde la documentación de tareas del código VS

descripción de la propiedad de tipo :

• type : el tipo de tarea. Para una tarea personalizada, esto puede ser shell o proceso. Si se especifica shell, el comando se interpreta como un comando de shell (por ejemplo: bash, cmd o PowerShell). Si se especifica proceso, el comando se interpreta como un proceso a ejecutar.

El comportamiento de la terminal se puede controlar mediante la propiedad de presentación en tasks.json . Ofrece las siguientes propiedades:

• Revelar : controla si el panel de terminales integrados se coloca al frente. Los valores válidos son:

  • siempre : el panel siempre se lleva al frente. Este es el predeterminado
  • nunca : el usuario debe traer explícitamente el panel de la terminal al frente usando el comando Ver> Terminal (Ctrl + `).
  • silencioso : el panel de terminales se pone al frente solo si la salida no se escanea para detectar errores y advertencias.

• focus : Controla si el terminal está tomando el enfoque de entrada o no. El valor predeterminado es falso.

• echo : controla si el comando ejecutado se repite en la terminal. El valor predeterminado es verdadero.
• showReuseMessage : Controla si se muestra el mensaje "El terminal será reutilizado por tareas, presione cualquier tecla para cerrarlo".
• panel : controla si la instancia de terminal se comparte entre las ejecuciones de tareas. Los posibles valores son:
  • compartido : el terminal se comparte y la salida de otras ejecuciones de tareas se agregan al mismo terminal.
  • dedicado : el terminal está dedicado a una tarea específica. Si esa tarea se vuelve a ejecutar, el terminal se reutiliza. Sin embargo, el resultado de una tarea diferente se presenta en un terminal diferente.
  • nuevo : cada ejecución de esa tarea utiliza una nueva terminal limpia.
• clear: controla si el terminal se borra antes de ejecutar esta tarea. El valor predeterminado es falso.

Frustrado por la falta de documentación clara, he creado un proyecto de Mac en github que debería funcionar (tanto en la construcción como en la depuración):

vscode-mac-c-ejemplo

Tenga en cuenta que requiere XCode y la extensión VSCode Microsoft cpptools.

Planeo hacer lo mismo para Windows y Linux (a menos que Microsoft escriba primero documentación decente ...).

En primer lugar, vaya a las extensiones (Ctrl + Shift + X) e instale 2 extensiones:

1. Corredor de código
2. C / C ++

Luego, vuelva a cargar el Código VS y seleccione un botón de reproducción en la parte superior de la esquina derecha que su programa se ejecuta en la terminal de salida. Puede ver la salida mediante Ctrl + Alt + N. Para cambiar otras funciones, vaya a la configuración del usuario.

El problema básico aquí es que construir y vincular un programa C ++ depende en gran medida del sistema de construcción que se use. Deberá admitir las siguientes tareas distintas, utilizando alguna combinación de complementos y código personalizado:

1. Soporte de lenguaje C ++ general para el editor. Esto generalmente se hace usando ms-vscode.cpptools, que la mayoría de la gente espera que también maneje muchas otras cosas, como el soporte de compilación. Déjame ahorrarte algo de tiempo: no es así. Sin embargo, probablemente lo querrá de todos modos.

2. Construir, limpiar y reconstruir tareas. Aquí es donde su elección de sistema de construcción se convierte en un gran problema. Encontrarás complementos para cosas como CMake y Autoconf (que Dios te ayude), pero si estás usando algo como Meson y Ninja, tendrás que escribir algunos scripts auxiliares y configurar un archivo "tasks.json" personalizado para manejar estos. Microsoft ha cambiado totalmente todo acerca de ese archivo en las últimas versiones, hasta cómo se supone que debe llamarse y los lugares (sí, lugares) donde puede ir, por no hablar de cambiar completamente el formato. Peor aún, han mantenido una especie de compatibilidad con versiones anteriores, para asegurarse de usar la clave de "versión" para especificar qué variante desea. Ver detalles aquí:

https://code.visualstudio.com/docs/editor/tasks

... pero tenga en cuenta los conflictos con:

https://code.visualstudio.com/docs/languages/cpp

ADVERTENCIA: EN TODAS LAS RESPUESTAS A CONTINUACIÓN, TODO LO QUE COMIENCE CON UNA ETIQUETA DE "VERSIÓN" ABAJO 2.0.0 ES OBSOLETO.

Aquí está lo más parecido que tengo en este momento. Tenga en cuenta que dejo la mayor parte del trabajo pesado a los scripts, esto realmente no me da ninguna entrada de menú con la que pueda vivir, y no hay ninguna buena manera de seleccionar entre depuración y liberación sin solo hacer otras tres entradas explícitas en aquí. Con todo lo dicho, esto es lo que puedo tolerar como mi archivo .vscode / tasks.json en este momento:

{
// See https://go.microsoft.com/fwlink/?LinkId=733558
// for the documentation about the tasks.json format
"version": "2.0.0",
"tasks": [
    {
        "label": "build project",
        "type": "shell",
        "command": "buildscripts/build-debug.sh",
        "args": [],

        "group": {
            "kind": "build",
            "isDefault": true
        },
        "presentation": {
            // Reveal the output only if unrecognized errors occur.
            "echo": true,
            "focus": false,
            "reveal": "always",
            "panel": "shared"
        },

        // Use the standard MS compiler pattern to detect errors, warnings and infos
        "options": {
            "cwd": "${workspaceRoot}"
        },
        "problemMatcher": {
            "owner": "cpp",
            "fileLocation": ["relative", "${workspaceRoot}/DEBUG"],
            "pattern": {
                "regexp": "^(.*):(\\d+):(\\d+):\\s+(warning|error):\\s+(.*)$",
                "file": 1,
                "line": 2,
                "column": 3,
                "severity": 4,
                "message": 5
            }
        }
    },
    {
        "label": "rebuild project",
        "type": "shell",
        "command": "buildscripts/rebuild-debug.sh",
        "args": [],
        "group": {
            "kind": "build",
            "isDefault": true
        },
        "presentation": {
            // Reveal the output only if unrecognized errors occur.
            "echo": true,
            "focus": false,
            "reveal": "always",
            "panel": "shared"
        },

        // Use the standard MS compiler pattern to detect errors, warnings and infos
        "options": {
            "cwd": "${workspaceRoot}"
        },
        "problemMatcher": {
            "owner": "cpp",
            "fileLocation": ["relative", "${workspaceRoot}/DEBUG"],
            "pattern": {
                "regexp": "^(.*):(\\d+):(\\d+):\\s+(warning|error):\\s+(.*)$",
                "file": 1,
                "line": 2,
                "column": 3,
                "severity": 4,
                "message": 5
            }
        }
    },
    {
        "label": "clean project",
        "type": "shell",
        "command": "buildscripts/clean-debug.sh",
        "args": [],

        "group": {
            "kind": "build",
            "isDefault": true
        },
        "presentation": {
            // Reveal the output only if unrecognized errors occur.
            "echo": true,
            "focus": false,
            "reveal": "always",
            "panel": "shared"
        },

        // Use the standard MS compiler pattern to detect errors, warnings and infos
        "options": {
            "cwd": "${workspaceRoot}"
        },
        "problemMatcher": {
            "owner": "cpp",
            "fileLocation": ["relative", "${workspaceRoot}/DEBUG"],
            "pattern": {
                "regexp": "^(.*):(\\d+):(\\d+):\\s+(warning|error):\\s+(.*)$",
                "file": 1,
                "line": 2,
                "column": 3,
                "severity": 4,
                "message": 5
            }
        }
    }
]

}

Tenga en cuenta que, en teoría, se supone que este archivo funciona si lo coloca en la raíz del espacio de trabajo, para que no se quede atascado revisando archivos en directorios ocultos (.vscode) en su sistema de control de revisiones. Todavía tengo que ver que eso realmente funcione; pruébelo, pero si falla, póngalo en .vscode. De cualquier manera, el IDE se quejará si no está allí de todos modos. (Sí, por el momento, esto significa que me he visto obligado a verificar .vscode en subversion, lo cual no me satisface). Tenga en cuenta que mis scripts de compilación (no se muestran) simplemente crean (o recrean) un directorio DEBUG usando, en my case, meson, y construir dentro de él (usando, en mi caso, ninja).

3. Ejecutar, depurar, adjuntar, detener. Se trata de otro conjunto de tareas, definido en "launch.json". O al menos solían serlo. Microsoft ha hecho un hash de la documentación, ya ni siquiera estoy seguro.

Si su proyecto tiene una configuración de CMake, es bastante sencillo configurar VSCode, por ejemplo, configure tasks.jsoncomo se muestra a continuación:

{
    "version": "0.1.0",
    "command": "sh",
    "isShellCommand": true,
    "args": ["-c"],
    "showOutput": "always",
    "suppressTaskName": true,
    "options": {
        "cwd": "${workspaceRoot}/build"
    },
    "tasks": [
        {
            "taskName": "cmake",
            "args": ["cmake ."]
        },
        {
            "taskName": "make",
            "args" : ["make"],
            "isBuildCommand": true,
            "problemMatcher": {
                "owner": "cpp",
                "fileLocation": "absolute",
                "pattern": {
                    "regexp": "^(.*):(\\d+):(\\d+):\\s+(warning|error):\\s+(.*)$",
                    "file": 1,
                    "line": 2,
                    "column": 3,
                    "severity": 4,
                    "message": 5
                }
            }
        }
    ]
}

Esto supone que hay una carpeta builden la raíz del espacio de trabajo con una configuración de CMake.

También hay una extensión de integración de CMake que agrega un comando "CMake build" a VScode.

¡PD! El problemMatcherestá configurado para clang-builds. Para usar GCC, creo que debe cambiar fileLocationa relative, pero no lo he probado.

Así es como configuré mi VS para C ++ usando el compilador g ++ y funciona muy bien, incluidas las opciones de depuración:

archivo tasks.json

{
    "version": "0.1.0",
    "command": "g++",
    "isShellCommand": true,
    // compiles and links with debugger information
    "args": ["-g", "-o", "hello.exe", "hello.cpp"],
    // without debugger information
    // "args": ["-o", "hello.exe", "hello.cpp"],
    "showOutput": "always"
}

archivo launch.json

{
    "version": "0.2.0",
    "configurations": [
        {
            "name": "C++ Launch (Windows)",
            "type": "cppdbg",
            "request": "launch",
            "program": "${workspaceRoot}/hello.exe",
            "MIMode": "gdb",
            "miDebuggerPath": "C:\\MinGw\\bin\\gdb.exe",
            "stopAtEntry": false,
            "cwd": "${workspaceRoot}",
            "externalConsole": false,
            "visualizerFile": "${workspaceRoot}/my.natvis"
        }
    ]
}

También tengo la extensión 'C / C ++ para Visual Studio Code' instalada en VS Code

Con un VS Code actualizado puede hacerlo de la siguiente manera:

1. Presione ( Ctrl+ P) y escriba:

   ext install cpptools
   

2. Abra una carpeta ( Ctrl+ K& Ctrl+ O) y cree un nuevo archivo dentro de la carpeta con la extensión .cpp (por ejemplo: hello.cpp ):

3. Escriba su código y presione guardar.

4. Presione ( Ctrl+ Shift+ Py escriba, Configure task runnery luego seleccione otheren la parte inferior de la lista.

5. Cree un archivo por lotes en la misma carpeta con el nombre build.bat e incluya el siguiente código en el cuerpo del archivo:

   @echo off
   call "C:\Program Files (x86)\Microsoft Visual Studio 14.0\VC\vcvarsall.bat" x64     
   set compilerflags=/Od /Zi /EHsc
   set linkerflags=/OUT:hello.exe
   cl.exe %compilerflags% hello.cpp /link %linkerflags%
   

6. Edite el archivo task.json de la siguiente manera y guárdelo :

   {
   // See https://go.microsoft.com/fwlink/?LinkId=733558
   // for the documentation about the tasks.json format
   "version": "0.1.0",
   "command": "build.bat",
   "isShellCommand": true,
   //"args": ["Hello World"],
   "showOutput": "always"
   }
   

7. Pulse ( Ctrl+ Shift+ Bpara ejecutar la tarea de compilación. Esto creará los archivos .obj y .exe para el proyecto.

8. Para depurar el proyecto, presione F5y seleccione C ++ (Windows) .

9. En el archivo launch.json , edite la siguiente línea y guarde el archivo:

   "program": "${workspaceRoot}/hello.exe",
   

10. Hit F5.

Puede hacer referencia a esta última esencia que tiene una 2.0.0tarea de versión para Visual Studio Code, https://gist.github.com/akanshgulati/56b4d469523ec0acd9f6f59918a9e454

Puede compilar y ejecutar fácilmente cada archivo sin actualizar la tarea. Es genérico y también abre la terminal para entradas de entrada.

Puede usar Extension Code Runner para ejecutar código con el icono de reproducción en la parte superior derecha y mediante la tecla de acceso directo: Ctrl+Alt+Ny para cancelar Ctrl+Alt+M. Pero, de forma predeterminada, solo muestra la salida del programa, pero para recibir la entrada debe seguir algunos pasos:

Ctrl +, y luego se abre el menú de configuración y Extensiones> Ejecutar configuración de código, desplácese hacia abajo por sus atributos y busque Editar en settings.json haga clic en él y agregue el siguiente código en el lugar:

{ "code-runner.runInTerminal": true }

Ahora hay una extensión de lenguaje C / C ++ de Microsoft. Puede instalarlo yendo a la opción de "apertura rápida" ( Ctrl+ p) y escribiendo:

ext install cpptools

Usted puede leer sobre ello aquí:

https://blogs.msdn.microsoft.com/vcblog/2016/03/31/cc-extension-for-visual-studio-code/

Es muy básico, a partir de mayo de 2016.