Tutorial: Men-debug kode C++ dengan Visual Studio

Dalam tutorial ini, Anda men-debug aplikasi C++ menggunakan debugger Visual Studio. Saat men-debug aplikasi, Anda biasanya menjalankan aplikasi dengan debugger yang terpasang. Debugger menyediakan banyak cara untuk memeriksa apa yang dilakukan kode Anda selama eksekusi program. Anda dapat menelusuri kode Anda dan melihat nilai yang disimpan dalam variabel dan mengatur jam tangan pada variabel untuk melihat kapan nilai berubah. Debugger membantu Anda memeriksa jalur eksekusi kode Anda dan mengonfirmasi cabang kode sedang berjalan.

Dalam tutorial ini, Anda:

• Mulai debugger dan jeda pada titik penghentian
• Pelajari perintah untuk menelusuri kode di debugger
• Menganalisis variabel dalam petunjuk data dan jendela debugger
• Periksa tumpukan panggilan
• Mengatur argumen baris perintah untuk aplikasi Anda

Jika Anda baru melakukan debugging, Anda mungkin ingin membaca Debugging untuk pemula absolut sebelum memulai tutorial ini. Jika Anda menginginkan tampilan tingkat yang lebih tinggi dari fitur debugger, lihat Pertama-tama lihat debugger.

Prasyarat

• Visual Studio 2022 versi 17.12 atau yang lebih baru dengan beban kerja Desktop dengan C++ terinstal.

  • Untuk menginstal Visual Studio secara gratis, buka halaman unduhan Visual Studio.

  • Jika Anda sudah memiliki Visual Studio, Anda dapat menginstal beban kerja dari dalam Interactive Development Environment (IDE):

    1. Pilih Alat >Dapatkan Alat dan Fitur.
    2. Di Penginstal Visual Studio, pilih tab Beban Kerja.
    3. Pilih beban kerja Pengembangan desktop dengan C++, lalu pilih Ubah.
    4. Ikuti perintah dan selesaikan penginstalan.

• Tutorial ini menggunakan aplikasi demo C++ dan cuplikan layar menyajikan sintaks C++. Sebagian besar fitur yang ditunjukkan juga berlaku untuk C#, Visual Basic, F#, Python, JavaScript, dan bahasa lain yang didukung oleh Visual Studio. Ada beberapa batasan yang perlu diingat:

  • F#: Fitur Edit dan lanjutkan tidak didukung.
  • F# dan JavaScript: Jendela Otomatis tidak didukung.

Membuat proyek

Ikuti langkah-langkah ini untuk membuat proyek aplikasi konsol C++ di Visual Studio. Jenis proyek menyediakan semua file templat yang Anda butuhkan untuk memulai dengan cepat:

1. Di jendela Mulai Visual Studio (Jendela Mulai>Jendela Mulai), pilih Buat proyek baru:

   

2. Atur filter Bahasa ke C++ dan atur filter Platform ke Windows.

3. Di kotak Pencarian, masukkan konsol, dan pilih templat Aplikasi Konsol dalam daftar hasil:

   

   Nota

   Jika Anda tidak melihat templat Console App, Anda dapat menginstalnya dari jendela Membuat proyek baru. Temukan bagian Tidak menemukan apa yang Anda cari? yang mengikuti hasil pencarian dan pilih Instal lebih banyak alat dan fitur. Di Penginstal Visual Studio, pilih pekerjaan Pengembangan desktop dengan C++ dan perbarui penginstalan Anda. Untuk informasi selengkapnya, lihat bagian Prasyarat.

4. Pilih Berikutnya untuk melanjutkan ke halaman konfigurasi.

5. Masukkan get-started-debugging sebagai Nama proyek dan Nama solusi untuk aplikasi baru Anda. Pilih Lokasi default atau telusuri ke jalur lain di lingkungan Anda.

6. Pilih Buat untuk membuat proyek Node.js baru.

Visual Studio membuat proyek baru Anda dan membuka hierarki proyek Anda di Solution Explorer. File get-started-debugging.cpp terbuka di editor kode.

Membuat aplikasi

Buat aplikasi baru untuk proyek Anda dengan mengedit get-started-debugging.cpp file di editor kode.

Ganti konten default yang disediakan oleh templat dengan kode berikut:

#include <string>
#include <vector>
#include <iostream>

void SendMessage(const std::wstring& name, int msg)
{
   std::wcout << L"Hello, " << name << L"! Count to " << msg << std::endl;
}

int main()
{
   std::vector<wchar_t> letters = { L'f', L'r', L'e', L'd', L' ', L's', L'm', L'i', L't', L'h' };
   std::wstring name = L"";
   std::vector<int> a(10);
   std::wstring key = L"";

   for (int i = 0; i < letters.size(); i++)
   {
      name += letters[i];
      a[i] = i + 1;
      SendMessage(name, a[i]);
   }
   std::wcin >> key;
   return 0;
}

Mulai debugger

Sekarang Anda siap untuk mulai men-debug kode yang diperbarui:

1. Mulai sesi debug dengan memilih F5 atau Debug > Mulai Debug. Anda juga dapat memilih Mulai Debugging (ikon panah hijau solid) di toolbar Debug.

   Pintasan papan ketik F5 memulai aplikasi dengan debugger yang menyertai proses aplikasi, tetapi belum ada yang istimewa untuk diperiksa di dalam kode. Aplikasi ini berfungsi dan Anda melihat hasil konsol:

   Hello, f! Count to 1
   Hello, fr! Count to 2
   Hello, fre! Count to 3
   Hello, fred! Count to 4
   Hello, fred ! Count to 5
   Hello, fred s! Count to 6
   Hello, fred sm! Count to 7
   Hello, fred smi! Count to 8
   Hello, fred smit! Count to 9
   Hello, fred smith! Count to 10
   

   Kemudian dalam tutorial, Anda melihat lebih dekat aplikasi ini di debugger dan menjelajahi fitur debugging lainnya.

2. Hentikan debugger dengan memilih Hentikan (ikon persegi merah) di toolbar Debug. Anda juga dapat menggunakan pintasan keyboard Shift + F5.

3. Di jendela konsol untuk aplikasi yang sedang berjalan, pilih kunci apa pun lalu pilih Masukkan untuk menutup jendela.

Mengatur titik henti dan memulai debugger

Coba atur titik henti dan jeda pada titik yang dipilih di debugger:

1. Kembali ke get-started-debugging.cpp file di editor kode, dan temukan perulangan formain fungsi:

      for (int i = 0; i < letters.size(); i++)
      {
         name += letters[i];
         a[i] = i + 1;
         SendMessage(name, a[i]);
      }
   

2. Atur titik henti pada baris yang berisi perintah kode name += letters[i]; dengan memilih di gutter kiri pada baris perintah tersebut. Visual Studio menambahkan lingkaran merah di gutter untuk menunjukkan titik henti yang ditetapkan.

   Tips

   Anda juga dapat menempatkan kursor pada baris kode dan memilih F9 untuk mengalihkan titik henti untuk baris tersebut.

   Titik henti adalah salah satu fitur paling mendasar dan penting dari debugging yang andal. Titik henti menunjukkan tempat Anda ingin Visual Studio menangguhkan kode yang sedang berjalan. Ketika eksekusi dijeda, Anda dapat melihat nilai variabel, memeriksa perilaku memori, atau memeriksa apakah cabang kode sedang dijalankan.

3. Mulai aplikasi Anda di debugger dengan memilih F5 atau Mulai Debugging.

   Visual Studio memulai eksekusi aplikasi Anda. Saat debugger mencapai titik henti yang Anda tetapkan, proses penelusuran kesalahan berhenti.

   Visual Studio menambahkan panah kuning ke lingkaran titik henti merah di selokan untuk mewakili pernyataan kode tempat debugger dijeda. Eksekusi program dijeda dan pernyataan yang ditunjukkan menunggu untuk diproses.

   

   Nota

   Tindakan F5 relatif terhadap status eksekusi aplikasi Anda saat ini. Jika aplikasi Anda tidak berjalan dan Anda memilih F5, debugger memulai aplikasi Anda dan melanjutkan eksekusi hingga mencapai titik henti set pertama. Perilaku ini memetakan ke perintahDebug > Mulai Debugging. Jika aplikasi Anda sudah berjalan dan Anda memilih F5, eksekusi aplikasi berlanjut hingga debugger mencapai titik henti atau akhir program berikutnya. Perilaku ini berkaitan dengan perintah Debug>Lanjutkan.

Titik henti adalah fitur yang berguna saat Anda mengetahui baris kode atau bagian kode yang ingin Anda periksa secara rinci. Untuk informasi tentang berbagai jenis titik henti yang dapat Anda atur, seperti titik henti kondisional, lihat Menggunakan jenis titik henti yang tepat.

Menelusuri kode Anda di debugger

Cara mudah untuk menelusuri kode Anda di debugger adalah dengan menggunakan perintah langkah . Perintah ini memungkinkan Anda Melangkah Ke, Langkah Atas, dan Langkah Keluar dari bagian kode, dan juga Langkah Mundur dalam eksekusi aplikasi.

Prosedur berikut menyoroti cara menggunakan pintasan keyboard dengan perintah langkah-langkah untuk mengolah kode Anda secara cepat. (Tindakan menu yang setara ditampilkan dalam tanda kurung.)

1. Mulai aplikasi Anda di debugger dengan memilih F5 atau Mulai Debugging.

2. Saat debugger dijeda dalam perulangan for dalam fungsi main, pilih F11 (Debug > Step Into) dua kali untuk melanjutkan ke pemanggilan metode SendMessage.

   Setelah Anda memilih F11 dua kali, eksekusi berlanjut ke pernyataan kode SendMessage(name, a[i]);.

3. Pilih F11 lagi untuk masuk ke metode SendMessage.

   Perhatikan bahwa pointer kuning maju ke metode SendMessage:

   

   Pintasan keyboard F11 memulai perintah Step Into, yang memajukan eksekusi aplikasi satu per satu. Ini adalah cara yang baik untuk memeriksa alur eksekusi secara terperinci. Secara default, debugger melompati kode nonpengguna. Untuk informasi selengkapnya, lihat Just My Code. Kemudian dalam tutorial, Anda mempelajari cara untuk bergerak lebih cepat melalui kode Anda.

4. Setelah memeriksa metode SendMessage, Anda dapat melanjutkan penelusuran kesalahan dengan perintah Langkah Keluar . Pilih Shift + F11 (Debug > Keluar).

   Perintah ini melanjutkan eksekusi aplikasi (dan memajukan debugger) hingga metode atau fungsi saat ini kembali.

   Ketika perintah selesai, debugger berhenti sejenak dalam perulangan for metode main pada panggilan metode SendMessage.

5. Pilih F11 beberapa kali hingga Anda kembali lagi ke panggilan metode SendMessage.

6. Saat debugger dijeda pada panggilan metode, pilih F10 (Debug > Langkah Atas).

   

   Perhatikan kali ini bahwa debugger tidak masuk ke metode SendMessage. Pintasan F10 memajukan debugger tanpa melangkah ke fungsi atau metode dalam kode aplikasi Anda (kode masih dijalankan). Saat Anda memilih F10 dalam panggilan metode SendMessage (alih-alih F11), Anda melangkahi kode implementasi untuk SendMessage. Pendekatan ini berguna untuk melewati kode yang tidak perlu Anda periksa saat ini. Untuk informasi selengkapnya tentang berbagai cara untuk berpindah melalui kode Anda, lihat Menavigasi kode di debugger.

Telusuri kode Anda dengan fitur 'Run to Click'

Cara lain untuk bekerja melalui kode Anda di debugger adalah dengan fitur Jalankan Hingga Klik. Tindakan ini mirip dengan mengatur titik henti sementara.

Lanjutkan sesi debugging Anda:

1. Pilih F5 untuk melanjutkan ke titik henti dalam kode Anda.

2. Di editor kode, gulir ke definisi metode SendMessage, dan arahkan mouse ke atas fungsi std::wcout.

   Arahkan mouse ke Run to Click (ikon panah hijau) yang muncul di sebelah kiri baris kode. Jika Anda mengarahkan kursor ke ikon, Anda akan melihat tooltip "Jalankan proses hingga di sini".

   

3. Pilih Jalankan untuk Mengklik .

   Debugger memajukan eksekusi ke posisi yang ditunjukkan. Dalam contoh ini, debugger mencapai panggilan ke fungsi std::wcout.

Tindakan Jalankan dengan Klik berguna untuk menavigasi dengan cepat dalam bagian kode aplikasi yang terlihat. Anda dapat menggunakan fitur dalam file apa pun yang terbuka di editor kode.

Mulai ulang aplikasi Anda dengan cepat

Mulai ulang aplikasi Anda dengan cepat dengan memilih Mulai ulang (ikon panah melingkar) di Toolbar Debug. Anda juga dapat memilih Debug > Mulai Ulang atau menggunakan pintasan keyboard Ctrl + Shift + F5.

Fitur Restart lebih efisien daripada menghentikan aplikasi dan memulai debugger lagi.

Saat Anda memilih Mulai ulang, debugger berhenti sejenak pada titik henti pertama yang ditemuinya selama eksekusi. Dalam contoh ini, debugger berhenti lagi di titik henti yang Anda atur di dalam perulangan for.

Memeriksa variabel dengan petunjuk data

Fitur yang membantu Anda memeriksa variabel adalah salah satu manfaat paling berguna untuk bekerja dengan debugger. Seringkali, ketika Anda men-debug masalah, Anda mencoba menemukan apakah variabel menyimpan nilai yang diharapkan pada waktu tertentu. Visual Studio menyediakan beberapa cara untuk membantu Anda menyelesaikan tugas ini.

Lanjutkan sesi debugging Anda:

1. Saat debugger dijeda pada pernyataan name += letters[i], arahkan mouse ke atas variabel letters. Pilih panah perluas/ciutkan di sebelah kiri nama variabel dan lihat propertinya di menu flyout.

   Fitur untuk tips data menunjukkan semua elemen yang ada dalam variabel. Perhatikan nilai default, size={10}:

   

2. Selanjutnya, arahkan mouse ke atas variabel name dan perhatikan nilainya saat ini, string kosong ("").

3. Pilih F5 (Debug>Lanjutkan) beberapa kali untuk melakukan iterasi beberapa kali melalui perulangan for. Setiap kali debugger berhenti sejenak di titik henti, arahkan mouse ke atas variabel name dan periksa nilai saat ini:

   

   Nilai variabel berubah dengan setiap iterasi perulangan for, memperlihatkan nilai f, lalu fr, lalu fre, dan sebagainya.

Memeriksa variabel dengan jendela Otomatis dan Lokal

Pendekatan lain untuk memeriksa variabel dan nilai adalah dengan menggunakan jendela Autos dan Locals. Secara bawaan, jendela ini muncul di bawah editor kode dalam Visual Studio IDE saat Anda melakukan debugging pada aplikasi Anda.

1. Perhatikan jendela Autos di bawah editor kode.

   Jika Anda tidak melihat jendela selama sesi debugging, pilih Debug>Windows>Autos untuk membukanya.

   Jendela Autos menunjukkan semua variabel yang digunakan pada baris saat ini atau baris sebelumnya bersama dengan nilainya saat ini. Perlu diingat bahwa bahasa pemrograman tertentu dapat menunjukkan perilaku unik untuk variabel dan properti. Untuk informasi selengkapnya, lihat Panduan Bahasa Visual Studio.

2. Selanjutnya, lihat jendela lokal. Secara bawaan, jendela ini dijajarkan di samping jendela Autos.

   Jika Anda tidak melihat jendela selama sesi debugging, pilih Debug>Windows>Locals untuk membuka jendela

3. Di jendela Lokal, perluas variabel letters untuk menampilkan elemen yang dikandungnya.

   

   Jendela Locals menunjukkan kepada Anda variabel yang berada dalam cakupan saat ini, yaitu konteks eksekusi saat ini.

Tonton variabel

Jika Anda tertarik untuk menonton perilaku variabel tertentu, Anda dapat mengatur jam :

Di editor kode, klik kanan variabel name dan pilih Tambahkan Watch. Jendela Watch terbuka di bawah editor kode. Anda dapat menggunakan jendela Watch untuk menentukan variabel (atau ekspresi) yang ingin Anda lacak.

Saat Anda menonton variabel name selama eksekusi aplikasi di debugger, Anda dapat melihat perubahan nilainya. Tidak seperti jendela variabel lainnya, jendela Watch selalu menampilkan variabel yang Anda tonton. Saat variabel yang ditonton tidak berada dalam cakupan, nama variabel diredupkan.

Periksa tumpukan panggilan

Jendela Call Stack di Visual Studio menunjukkan urutan di mana metode dan fungsi dipanggil. Jendela ini mirip dengan perspektif Debug di beberapa IDE seperti Eclipse. Secara default, tumpukan panggilan terlihat di panel kanan bawah selama sesi penelusuran kesalahan di bawah editor kode.

1. Saat debugger dijeda di perulangan for, pilih jendela Call Stack untuk melihat struktur panggilan saat ini.

   Jika Anda tidak melihat jendela selama sesi penelusuran kesalahan, pilih Debug>Windows>Call Stack untuk membuka jendela.

2. Pilih F11 (Debug>Melangkah ke) beberapa kali hingga Anda melihat jeda debugger dalam metode SendMessage.

3. Lihat lagi jendela Call Stack:

   

   Di jendela Call Stack, baris atas menunjukkan fungsi saat ini (metode SendMessage di aplikasi ini). Baris kedua menunjukkan bahwa metode SendMessage dipanggil dari metode main, dan sebagainya.

Tumpukan panggilan adalah cara yang baik untuk memeriksa dan memahami alur eksekusi aplikasi:

• Klik dua kali baris kode untuk menelusuri kode sumber. Tindakan ini juga mengubah cakupan yang sedang diperiksa oleh debugger, tetapi tidak membuat debugger maju.
• Akses menu klik kanan untuk elemen pemrograman di jendela Call Stack. Misalnya, Anda dapat menyisipkan titik henti ke dalam fungsi tertentu, menjalankan debugger dengan menggunakan Jalankan ke Kursor, dan menelusuri kode sumber. Untuk informasi selengkapnya, lihat Menampilkan tumpukan panggilan dan menggunakan jendela Call Stack di debugger.

Mengubah alur eksekusi

Fitur debugger kuat lainnya adalah kemampuan untuk memodifikasi alur eksekusi selama penelusuran kesalahan:

1. Pilih F11 (Debug>Melangkah ke) dua kali untuk menjalankan fungsi std::wcout.

2. Saat debugger dijeda dalam panggilan metode SendMessage, pilih dan seret panah kuning (penunjuk eksekusi) ke sebelah kiri variabel dan pindahkan panah ke pernyataan kode sebelumnya, std::wcout.

3. Pilih F11 lagi.

   Debugger menjalankan ulang fungsi std::wcout. Anda dapat melacak proses dalam output terminal.

   Dengan mengubah alur eksekusi, Anda dapat melakukan hal-hal seperti menguji jalur eksekusi kode yang berbeda atau menjalankan ulang kode tanpa memulai ulang debugger.

   Perhatian

   Perhatikan dengan cermat saat bekerja dengan fitur ini. Saat Anda memilih panah kuning, Visual Studio menampilkan peringatan di tipsalat yang menunjukkan bahwa perubahan eksekusi dapat memiliki konsekuensi yang tidak diinginkan. Anda mungkin juga melihat peringatan lain, tergantung pada skenario Anda. Perlu diingat bahwa memindahkan pointer tidak dapat mengembalikan aplikasi Anda ke status aplikasi sebelumnya.

4. Pilih F5 untuk menyelesaikan eksekusi aplikasi.

Meneruskan argumen baris perintah

Atur argumen baris perintah untuk aplikasi Anda di properti proyek. Ini berguna saat Anda ingin menguji perilaku aplikasi Anda dengan argumen baris perintah yang berbeda.

Mulai dari Visual Studio 2026, Anda dapat mengatur argumen baris perintah untuk aplikasi Anda di daftar drop-down toolbar argumen baris perintah. Fitur ini tersedia untuk proyek Visual Studio C++, proyek Unreal Engine .uproject , dan proyek CMake. Saat ini dalam pratinjau dan dapat berubah sebelum rilis akhir.

Ubah aplikasi untuk menerima argumen baris perintah dengan mengganti kode dalam get-started-debugging.cpp file dengan yang berikut:

#include <string>
#include <vector>
#include <iostream>
#include <algorithm>

void SendMessage(const std::wstring& name, int msg)
{
    std::wcout << L"Hello, " << name << L"! Count to " << msg << std::endl;
}

int main(int argc, char* argv[])
{
    // Detect if the /u command-line argument was passed to the application.
    bool uppercase = false;
    for (int i = 1; i < argc; ++i)
    {
        if (std::string(argv[i]) == "/u")
        {
            uppercase = true;
            break;
        }
    }

    std::vector<wchar_t> letters = { L'f', L'r', L'e', L'd', L' ', L's', L'm', L'i', L't', L'h' };
    std::wstring name = L"";
    std::vector<int> a(10);
    std::wstring key = L"";

    for (int i = 0; i < letters.size(); i++)
    {
        name += letters[i];
        a[i] = i + 1;
        std::wstring nameToSend = name;

        if (uppercase) // Convert the name to uppercase if the /u argument was passed.
        {
            std::transform(nameToSend.begin(), nameToSend.end(), nameToSend.begin(), ::towupper);
        }
        SendMessage(nameToSend, a[i]);
    }
    return 0;
}

Versi aplikasi yang diperbarui ini menerima argumen /u baris perintah yang mengonversi nama menjadi huruf besar sebelum mengeluarkannya.

Untuk meneruskan /u argumen baris perintah ke aplikasi saat Anda mulai men-debugnya, ikuti langkah-langkah berikut:

1. Di toolbar Standar , kotak teks Argumen baris perintah , ketik /u:

   

2. Tempatkan titik henti pada baris 19, uppercase = true;, dengan mengklik selokan kiri pada baris tersebut.

   

3. Mulai penelusuran kesalahan aplikasi Anda dengan memilih tombol Mulai Penelusuran Kesalahan atau tekan F5.

4. Debugger mencapai titik henti karena /u diteruskan sebagai argumen baris perintah:

   

5. Pilih F5 untuk terus menjalankan aplikasi. Output di jendela konsol menunjukkan nama dalam huruf besar sekarang:

Hello, F! Count to 1
Hello, FR! Count to 2
Hello, FRE! Count to 3
Hello, FRED! Count to 4
Hello, FRED ! Count to 5
Hello, FRED S! Count to 6
Hello, FRED SM! Count to 7
Hello, FRED SMI! Count to 8
Hello, FRED SMIT! Count to 9
Hello, FRED SMITH! Count to 10

Argumen baris perintah disimpan dalam daftar drop-down dalam urutan yang Anda masukkan dan muncul di daftar drop-down untuk digunakan di masa mendatang. Ada batas lima baris perintah yang dapat Anda tambahkan sebelum baris terlama dihapus untuk memberi ruang bagi yang baru.

Anda dapat memilih panah daftar drop-down untuk melihat daftar argumen baris perintah yang digunakan sebelumnya.

Meneruskan argumen baris perintah dalam jenis proyek yang berbeda

Daftar drop-down argumen baris perintah berisi opsi spesifik jenis proyek untuk membuka cara klasik mengatur argumen yang diteruskan debugger ke program Anda. Untuk .vcxproj proyek, itu melalui halaman properti pengaturan proyek. Untuk proyek CMake, dengan mengedit vs.launch.json file. Untuk proyek Unreal Engine, ini dengan mengedit .uproject file.

Jenis proyek Visual Studio (.vcxproj)

Di proyek Visual Studio (.vcxproj), opsi muncul di daftar drop-down argumen baris perintah untuk Mengedit di Halaman Properti:

Pilih Edit di Halaman Properti untuk membuka jendela properti proyek ke halaman properti Debugging tempat Anda mengatur argumen baris perintah untuk diteruskan saat menelusuri kesalahan aplikasi Anda:

Perubahan pada Argumen Perintah tercermin dalam daftar drop-down argumen baris perintah untuk sesi penelusuran kesalahan di masa mendatang.

Jenis proyek CMake

Untuk proyek CMake, opsi muncul di daftar drop-down argumen baris perintah untuk Mengedit di launch.vs.json:

Pilih Edit di launch.vs.json, untuk membuka launch.vs.json file dan mengatur argumen baris perintah untuk diteruskan saat men-debug aplikasi Anda di "args" elemen :

Perubahan pada file tercermin dalam daftar drop-down argumen baris perintah untuk sesi penelusuran kesalahan di masa mendatang.

Jenis proyek Unreal Engine (.uproject)

Untuk proyek Unreal Engine, opsi muncul di daftar drop-down argumen baris perintah untuk Mengedit di UETargetProperties.json:

Pilih Edit di UETargetProperties.json, untuk membuka UETargetProperties.json file tempat Anda mengatur argumen baris perintah untuk diteruskan saat menelusuri kesalahan aplikasi Anda di elemen "args":

Perubahan pada file tercermin dalam daftar drop-down argumen baris perintah untuk sesi penelusuran kesalahan di masa mendatang.

Konten terkait

• Pertama-tama lihat debugger Visual Studio
• Menavigasi melalui kode dengan menggunakan debugger Visual Studio
• Gunakan jenis titik henti yang tepat (.NET, .NET Framework, C++, Semua bahasa)