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

visual studio code portable

Question

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

¿Cómo lo configuro para hacer esto?

Answer 1

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

{
    "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"
        },

    ]
}

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.

Answer 2

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

Asegúrese de cambiar las rutas apropiadas a donde 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++"　　                  
           }
   ]
}

task.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 código VS

2. plantilla c_cpp_properties.json

Answer 3

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

tareas.json archivo

{
    "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"
        }
    ]
}

archivo launch.json

ext install cpptools

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

Answer 4

Con un código VS actualizado, puede hacerlo de la siguiente manera:

1. Presiona ( Ctrl + P ) y escribe:

   @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%

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

3. Escriba su código y presione guardar.

4. Presione ( Ctrl + Shift + P y escriba, Configure task runner y luego seleccione other al final 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:

   {
   // 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"
   }

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

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

7. Presione ( Ctrl + Shift + B para ejecutar la tarea Build. Esto creará los archivos .obj y .exe para el proyecto.

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

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

   ext install cpptools

10. Presiona F5 .

Answer 5

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

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

2. Construir, limpiar y reconstruir tareas. Aquí es donde su elección del 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 de ayuda y configurar un archivo personalizado "task.json" para manejar estos. Microsoft ha cambiado totalmente todo sobre ese archivo en las últimas versiones, hasta lo que se supone que debe llamarse y los lugares (sí, placeS) a los que puede ir, por no hablar de cambiar completamente el formato. Peor aún, SORT OF han mantenido la compatibilidad con versiones anteriores, para asegurarse de usar la tecla "versión" para especificar qué variante desea. Ver detalles aquí:

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

... pero nota 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 cercano que tengo en este momento. Tenga en cuenta que elimino la mayor parte del trabajo pesado en scripts, esto realmente no me da ninguna entrada de menú con la que pueda vivir, y no hay ninguna buena manera de seleccionar entre depurar y liberar sin simplemente hacer otras tres entradas explícitas en aquí. Con todo lo dicho, esto es lo que puedo tolerar como mi archivo .vscode / task.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, de modo que no esté atrapado comprobando archivos en directorios ocultos (.vscode) en su sistema de control de revisiones. Todavía tengo que ver que 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í, en este momento, esto significa que me he visto obligado a verificar .vscode en subversion, lo que no me agrada). Tenga en cuenta que mis scripts de compilación (no se muestran) simplemente crean (o recrean) un directorio DEBUG usando, en mi caso, mesón y construcción dentro de él (usando, en mi caso, ninja).

3. Ejecutar, depurar, adjuntar, detener. Estos son otro conjunto de tareas, definidas en "launch.json". O al menos solían ser. Microsoft ha hecho un gran hash de la documentación, ya ni siquiera estoy seguro.

Answer 6

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

vscode-mac-c-example

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 documentación decente primero ...).

Answer 7

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

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

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

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

Answer 8

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

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

Se abrirá el archivo task.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 → Métodos abreviados de teclado y agregue el siguiente enlace 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 presiona F8 , se ejecutará el Makefile y los errores se subrayarán en el editor.

Answer 9

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

Aquí proporciono algunos comentarios a mi archivo task.json para que el archivo sea más comprensible. Puede usarse como referencia para configurar task.json , espero que sea útil

task.json

{
    "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
                }
            }
        }
    ]
}

Ahora, indicando directamente desde la https://code.visualstudio.com/docs/editor/tasks

Descripción del tipo de propiedad:

• tipo : el tipo de tarea. Para una tarea personalizada, 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 el proceso, el comando se interpreta como un proceso a ejecutar.

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

• revelar : controla si el panel Terminal integrado se lleva al frente. Los valores válidos son:

  • siempre : el panel siempre se lleva al frente. Este es el valor predeterminado
  • nunca : el usuario debe llevar explícitamente el panel de terminales al frente con el comando Ver> Terminal (Ctrl + `).
  • Silencioso : el panel de terminales se muestra al frente solo si la salida no se escanea en busca de errores y advertencias.

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

• echo : controla si el comando ejecutado se repite en el 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 ejecuciones de tareas. Los valores posibles son:
  • shared : el terminal se comparte y la salida de otras ejecuciones de tareas se agrega al mismo terminal.
  • dedicado : El terminal está dedicado a una tarea específica. Si esa tarea se ejecuta nuevamente, 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 está utilizando un nuevo terminal limpio.
• clear: controla si el terminal se borra antes de ejecutar esta tarea. El valor predeterminado es falso.

Answer 10

Puede hacer referencia a este último resumen que tiene una tarea de la versión 2.0.0 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 el terminal para entradas de entrada.

Answer 11

Puede usar Extension Code Runner para ejecutar código con el icono de reproducción en la parte superior derecha y con la tecla de acceso directo: Ctrl+Alt+N y para cancelar Ctrl+Alt+M Pero, de manera predeterminada, solo muestra la salida del programa, pero para recibir información 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 interior:

{ "code-runner.runInTerminal": true }

Answer 12

Si su proyecto tiene una configuración CMake, es bastante sencillo configurar VSCode, por ejemplo, configurar tasks.json como a continuación:

{
    "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"
}

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

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

¡PD! El problemMatcher está configurado para clang -builds. Para usar GCC, creo que necesita cambiar fileLocation a relative , pero no lo he probado.

Answer 13

Un ejemplo de tarea makefile para la nueva versión 2.0.0 task.json.

En el fragmento a continuación algunos comentarios espero que sean útiles.

{
    "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
                }
            }
        }
    ]
}