Buka dukungan Folder untuk sistem build C++ di Visual Studio

Di Visual Studio 2017 dan yang lebih baru, fitur "Buka Folder" memungkinkan Anda membuka folder file sumber dan segera mulai mengoding dengan dukungan untuk IntelliSense, penjelajahan, pemfaktoran ulang, penelusuran kesalahan, dan sebagainya. Saat Anda mengedit, membuat, memindahkan, atau menghapus file, Visual Studio melacak perubahan secara otomatis dan terus memperbarui indeks IntelliSense-nya. Tidak ada file .sln atau .vcxproj yang dimuat; jika diperlukan, Anda dapat menentukan tugas kustom serta membangun dan meluncurkan parameter melalui file .json sederhana. Fitur ini memungkinkan Anda mengintegrasikan sistem build pihak ketiga ke Visual Studio. Untuk informasi umum tentang Buka Folder, lihat Mengembangkan kode di Visual Studio tanpa proyek atau solusi.

CMake dan Qt

CMake terintegrasi di Visual Studio IDE sebagai komponen beban kerja desktop C++. Alur kerja untuk CMake tidak identik dengan alur kerja yang dijelaskan dalam artikel ini. Jika Anda menggunakan CMake, lihat Proyek CMake di Visual Studio. Anda juga dapat menggunakan CMake untuk membangun proyek Qt, atau Anda dapat menggunakan Ekstensi Qt Visual Studio untuk Visual Studio 2015 atau Visual Studio 2017.

Sistem build lainnya

Untuk menggunakan IDE Visual Studio dengan sistem build atau toolset kompilator yang tidak didukung langsung dari menu utama pilih File | Buka | Folder atau tekan Ctrl + Shift + Alt + O. Navigasi ke folder yang berisi file kode sumber Anda. Untuk membangun proyek, konfigurasikan IntelliSense dan atur parameter debugging, Anda menambahkan tiga file JSON:

File	Deskripsi
CppProperties.json	Tentukan informasi konfigurasi kustom untuk penjelajahan. Buat file ini, jika diperlukan, di folder proyek akar Anda. (Tidak digunakan dalam proyek CMake.)
tasks.vs.json	Tentukan perintah build kustom. Diakses melalui item menu konteks Penjelajah Solusi Konfigurasikan Tugas.
launch.vs.json	Tentukan argumen baris perintah untuk debugger. Diakses melalui item menu konteks Penjelajah Solusi Debug dan Luncurkan Pengaturan.

Mengonfigurasi navigasi kode dengan CppProperties.json

Agar intelliSense dan perilaku penjelajahan seperti Buka Definisi berfungsi dengan benar, Visual Studio perlu mengetahui pengkompilasi mana yang Anda gunakan, di mana header sistem berada, dan di mana file tambahan termasuk berada jika file tersebut tidak langsung berada di folder yang telah Anda buka (folder ruang kerja). Untuk menentukan konfigurasi, Anda dapat memilih Kelola Konfigurasi dari menu dropdown di toolbar utama:

Visual Studio menawarkan konfigurasi default berikut:

Jika, misalnya, Anda memilih x64-Debug, Visual Studio membuat file yang disebut CppProperties.json di folder proyek akar Anda:

{
  "configurations": [
    {
      "inheritEnvironments": [
        "msvc_x64"
      ],
      "name": "x64-Debug",
      "includePath": [
        "${env.INCLUDE}",
        "${workspaceRoot}\\**"
      ],
      "defines": [
        "WIN32",
        "_DEBUG",
        "UNICODE",
        "_UNICODE"
      ],
      "intelliSenseMode": "windows-msvc-x64"
    }
  ]
}

Konfigurasi ini mewarisi variabel lingkungan dari Prompt Perintah Pengembang Visual Studio x64. Salah satu variabel tersebut adalah INCLUDE dan Anda dapat merujuknya di sini dengan menggunakan ${env.INCLUDE} makro. Properti memberi includePath tahu Visual Studio tempat mencari semua sumber yang dibutuhkan untuk IntelliSense. Dalam hal ini, tertulis "lihat di semua direktori yang ditentukan oleh variabel lingkungan INCLUDE, dan juga semua direktori di pohon folder kerja saat ini." Properti name adalah nama yang akan muncul di menu dropdown, dan bisa menjadi apa pun yang Anda suka. Properti defines ini memberikan petunjuk kepada IntelliSense ketika menemukan blok kompilasi bersyarat. Properti intelliSenseMode ini menyediakan beberapa petunjuk tambahan berdasarkan jenis pengkompilasi. Beberapa opsi tersedia untuk MSVC, GCC, dan Clang.

Catatan

Jika Visual Studio tampaknya mengabaikan pengaturan di CppProperties.json, coba tambahkan pengecualian ke file .gitignore Anda seperti ini: !/CppProperties.json.

Konfigurasi default untuk MinGW-w64

Jika Anda menambahkan konfigurasi MinGW-W64, JSON akan melihat ini:

{
  "configurations": [
    {
      "inheritEnvironments": [
        "mingw_64"
      ],
      "name": "Mingw64",
      "includePath": [
        "${env.INCLUDE}",
        "${workspaceRoot}\\**"
      ],
      "intelliSenseMode": "linux-gcc-x64",
      "environments": [
        {
          "MINGW64_ROOT": "C:\\msys64\\mingw64",
          "BIN_ROOT": "${env.MINGW64_ROOT}\\bin",
          "FLAVOR": "x86_64-w64-mingw32",
          "TOOLSET_VERSION": "9.1.0",
          "PATH": "${env.BIN_ROOT};${env.MINGW64_ROOT}\\..\\usr\\local\\bin;${env.MINGW64_ROOT}\\..\\usr\\bin;${env.MINGW64_ROOT}\\..\\bin;${env.PATH}",
          "INCLUDE": "${env.MINGW64_ROOT}\\include\\c++\\${env.TOOLSET_VERSION};${env.MINGW64_ROOT}\\include\\c++\\${env.TOOLSET_VERSION}\\tr1;${env.MINGW64_ROOT}\\include\\c++\\${env.TOOLSET_VERSION}\\${env.FLAVOR}",
          "environment": "mingw_64"
        }
      ]
    }
  ]
}

Perhatikan blok.environments Ini mendefinisikan properti yang berperilaku seperti variabel lingkungan dan tersedia tidak hanya dalam file CppProperties.json , tetapi juga di file konfigurasi lainnya task.vs.json dan launch.vs.json. Konfigurasi Mingw64 mewarisi mingw_w64 lingkungan, dan menggunakan propertinya INCLUDE untuk menentukan nilai untuk includePath. Anda dapat menambahkan jalur lain ke properti array ini sesuai kebutuhan.'

Properti intelliSenseMode diatur ke nilai yang sesuai untuk GCC. Untuk informasi selengkapnya tentang semua properti ini, lihat Referensi skema CppProperties.

Ketika semuanya bekerja dengan benar, Anda akan melihat IntelliSense dari header GCC saat Anda mengarahkan mouse ke atas jenis:

Mengaktifkan diagnostik IntelliSense

Jika Anda tidak melihat IntelliSense yang Anda harapkan, Anda dapat memecahkan masalah dengan membuka Opsi>Alat>Editor>Teks C/C++>Tingkat Lanjut dan mengatur Aktifkan Pengelogan ke .true Untuk memulai, coba atur Tingkat Pengelogan ke 5, dan Filter Pengelogan ke 8.

Output disalurkan ke Jendela Output dan terlihat saat Anda memilih *Tampilkan Output Dari: Log Visual C++. Output berisi, antara lain, daftar aktual termasuk jalur yang coba digunakan IntelliSense. Jika jalur tidak cocok dengan jalur di CppProperties.json, coba tutup folder dan hapus subfolder .vs yang berisi data penjelajahan cache.

Tentukan tugas build dengan tasks.vs.json

Anda dapat mengotomatiskan skrip build atau operasi eksternal lainnya pada file yang Anda miliki di ruang kerja Anda saat ini dengan menjalankannya sebagai tugas langsung di IDE. Anda dapat mengonfigurasi tugas baru dengan mengklik kanan file atau folder dan memilih Konfigurasikan Tugas.

Ini membuat (atau membuka) file tasks.vs.json di folder .vs yang dibuat Visual Studio di folder proyek akar Anda. Anda dapat menentukan tugas arbitrer apa pun dalam file ini lalu memanggilnya dari menu konteks Penjelajah Solusi. Untuk melanjutkan contoh GCC, cuplikan berikut menunjukkan file tasks.vs.json lengkap dengan sebagai tugas tunggal yang memanggil g++.exe untuk membangun proyek. Asumsikan proyek berisi satu file yang disebut hello.cpp.

{
  "version": "0.2.1",
  "tasks": [
    {
      "taskLabel": "build hello",
      "appliesTo": "/",
      "type": "default",
      "command": "g++",
      "args": [
        "-g",
        "-o",
        "hello",
        "hello.cpp"
      ]
    }
  ]
}

File JSON ditempatkan di subfolder .vs . Untuk melihat folder tersebut, klik tombol Perlihatkan Semua File di bagian atas Penjelajah Solusi. Anda dapat menjalankan tugas ini dengan mengklik kanan pada simpul akar di Penjelajah Solusi dan memilih build hello. Ketika tugas selesai, Anda akan melihat file baru, hello.exe di Penjelajah Solusi.

Anda dapat menentukan banyak jenis tugas. Contoh berikut menunjukkan file tasks.vs.json yang menentukan satu tugas. taskLabel menentukan nama yang muncul di menu konteks. appliesTo menentukan file mana yang dapat dilakukan oleh perintah. Properti command mengacu pada variabel lingkungan COMSPEC, yang mengidentifikasi jalur untuk konsol (cmd.exe di Windows). Anda juga dapat mereferensikan variabel lingkungan yang dideklarasikan dalam CppProperties.json atau CMake Pengaturan.json. Properti args menentukan baris perintah yang akan dipanggil. ${file} Makro mengambil file yang dipilih dalam Penjelajah Solusi. Contoh berikut akan menampilkan nama file dari file .cpp yang saat ini dipilih.

{
  "version": "0.2.1",
  "tasks": [
    {
      "taskLabel": "Echo filename",
      "appliesTo": "*.cpp",
      "type": "command",
      "command": "${env.COMSPEC}",
      "args": ["echo ${file}"]
    }
  ]
}

Setelah menyimpan tasks.vs.json, Anda dapat mengklik kanan file .cpp apa pun di folder, memilih nama file Echo dari menu konteks, dan melihat nama file yang ditampilkan di jendela Output.

Untuk informasi selengkapnya, lihat Referensi skema Tasks.vs.json.

Mengonfigurasi parameter penelusuran kesalahan dengan launch.vs.json

Untuk menyesuaikan argumen baris perintah dan instruksi penelusuran kesalahan program Anda, klik kanan pada yang dapat dieksekusi di Penjelajah Solusi dan pilih Debug dan Luncurkan Pengaturan. Ini akan membuka file launch.vs.json yang ada, atau jika tidak ada, file baru akan dibuat dengan serangkaian pengaturan peluncuran minimal. Pertama, Anda diberi pilihan sesi debug seperti apa yang ingin Anda konfigurasi. Untuk men-debug proyek MinGw-w64, kami memilih Peluncuran C/C++ untuk MinGW/Cygwin (gdb). Ini membuat konfigurasi peluncuran untuk menggunakan gdb.exe dengan beberapa tebakan terdidik tentang nilai default. Salah satu nilai default tersebut adalah MINGW_PREFIX. Anda dapat mengganti jalur literal (seperti yang ditunjukkan di bawah) atau Anda dapat menentukan MINGW_PREFIX properti di CppProperties.json:

{
  "version": "0.2.1",
  "defaults": {},
  "configurations": [
    {
      "type": "cppdbg",
      "name": "hello.exe",
      "project": "hello.exe",
      "cwd": "${workspaceRoot}",
      "program": "${debugInfo.target}",
      "MIMode": "gdb",
      "miDebuggerPath": "c:\\msys64\\usr\\bin\\gdb.exe",
      "externalConsole": true
    }
  ]
}

Untuk memulai penelusuran kesalahan, pilih yang dapat dieksekusi di menu dropdown debug, lalu klik panah hijau:

Anda akan melihat dialog Inisialisasi Debugger lalu jendela konsol eksternal yang menjalankan program Anda.

Untuk informasi selengkapnya, lihat referensi skema launch.vs.json.

Meluncurkan executable lainnya

Anda dapat menentukan setelan peluncuran untuk semua yang dapat dieksekusi pada komputer Anda. Contoh berikut meluncurkan 7za dan menentukan argumen tambahan, dengan menambahkannya ke args array JSON:

{
  "version": "0.2.1",
  "defaults": {},
  "configurations": [
    {
      "type": "default",
      "project": "CPP\\7zip\\Bundles\\Alone\\O\\7za.exe",
      "name": "7za.exe list content of helloworld.zip",
      "args": [ "l", "d:\\sources\\helloworld.zip" ]
    }
  ]
}

Saat Anda menyimpan file ini, konfigurasi baru muncul di dropdown Target Debug dan Anda dapat memilihnya untuk memulai debugger. Anda dapat membuat konfigurasi debug sebanyak yang Anda inginkan, untuk sejumlah executable. Jika Anda menekan F5 sekarang, debugger akan diluncurkan dan mencapai titik henti apa pun yang mungkin telah Anda tetapkan. Semua jendela debugger yang akrab dan fungsionalitasnya sekarang tersedia.