Samouczek: debugowanie kodu C++ za pomocą programu Visual Studio

W tym samouczku debugujesz aplikację języka C++ przy użyciu debugera programu Visual Studio. Podczas debugowania aplikacji zwykle uruchamiasz aplikację z dołączonym debugerem. Debuger udostępnia wiele sposobów sprawdzania, co robi kod podczas wykonywania programu. Możesz przejść przez kod i przyjrzeć się wartościom przechowywanym w zmiennych i ustawić zegarki na zmiennych, aby zobaczyć, kiedy wartości się zmieniają. Debuger pomaga zbadać ścieżkę wykonywania kodu i potwierdzić, że działa gałąź kodu.

W tym samouczku nauczysz się następujących rzeczy:

• Uruchom debuger i wstrzymaj się w punktach przerwania
• Learn commands to step through code in the debugger (Instrukcje dotyczące wykonywania kroków w kodzie w debugerze)
• Sprawdzanie zmiennych w poradach dotyczących danych i oknach debugera
• Badanie stosu wywołań
• Ustawianie argumentów wiersza polecenia dla aplikacji

Jeśli dopiero zaczynasz debugowanie, możesz przeczytać Debugowanie dla początkujących przed rozpoczęciem tego samouczka. Jeśli chcesz wyświetlić funkcje debugera wyższego poziomu, zobacz Najpierw zobacz debuger.

Warunki wstępne

• Program Visual Studio 2022 w wersji 17.12 lub nowszej z zainstalowanym obciążeniem Desktop w języku C++.

  • Aby zainstalować program Visual Studio bezpłatnie, przejdź do strony pobierania Visual Studio.

  • Jeśli masz już program Visual Studio, możesz zainstalować obciążenie z poziomu interaktywnego środowiska projektowego (IDE):

    1. Wybierz Narzędzia>Uzyskaj narzędzia i funkcje.
    2. W Instalatorze programu Visual Studio wybierz kartę Zadania.
    3. Wybierz pakiet roboczy Desktop z obciążeniem języka C++, a następnie wybierz pozycję Modyfikuj.
    4. Postępuj zgodnie z monitami i ukończ instalację.

• W tym samouczku użyto aplikacji demonstracyjnej języka C++, a zrzuty ekranu przedstawiają składnię języka C++. Większość przedstawionych funkcji ma również zastosowanie do języków C#, Visual Basic, F#, Python, JavaScript i innych języków obsługiwanych przez program Visual Studio. Należy pamiętać o kilku ograniczeniach:

  • języka F#: funkcja Edytuj i kontynuuj nie jest obsługiwana.
  • języka F# i JavaScript: okno Autos nie jest obsługiwane.

Tworzenie projektu

Wykonaj następujące kroki, aby utworzyć projekt aplikacji konsolowej języka C++ w programie Visual Studio. Typ projektu zawiera wszystkie pliki szablonów potrzebne do szybkiego rozpoczęcia pracy:

1. W oknie Start programu Visual Studio (File>okno Start) wybierz pozycję Utwórz nowy projekt:

   

2. Ustaw filtr języka na C++ i ustaw filtr platformy na Windows.

3. W polu wyszukiwania wprowadź konsolii wybierz szablon Aplikacja konsolowa na liście wyników:

   

   Notatka

   Jeśli nie widzisz szablonu Console App, możesz zainstalować go w oknie Create a new project (Tworzenie nowego projektu). Znajdź Nie możesz znaleźć tego, czego szukasz? sekcję, która pojawia się po wynikach wyszukiwania i wybierz opcję Zainstaluj więcej narzędzi i funkcji. W Instalatorze programu Visual Studio wybierz obciążenie robocze Desktop Development with C++ i zaktualizuj instalację. Aby uzyskać więcej informacji, zobacz sekcję Wymagania wstępne.

4. Wybierz pozycję Dalej, aby przejść do strony konfiguracji.

5. Wprowadź get-started-debugging jako nazwę projektu i nazwę rozwiązania dla nowej aplikacji. Wybierz domyślną Lokalizację lub przejdź do innej ścieżki w danym środowisku.

6. Wybierz pozycję Utwórz, aby utworzyć nowy projekt Node.js.

Program Visual Studio tworzy nowy projekt i otwiera hierarchię projektu w eksploratorze rozwiązań . Plik get-started-debugging.cpp jest otwarty w edytorze kodu.

Tworzenie aplikacji

Utwórz nową aplikację dla projektu, edytując get-started-debugging.cpp plik w edytorze kodu.

Zastąp domyślną zawartość dostarczaną przez szablon następującym kodem:

#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;
}

Uruchamianie debugera

Teraz możesz rozpocząć debugowanie zaktualizowanego kodu:

1. Rozpocznij sesję debugowania, wybierając pozycję F5 lub Debug > Start Debugging. Na pasku narzędzi Debugowanie możesz również wybrać Rozpocznij debugowanie (ikona zielonej stałej strzałki).

   Skrót klawiaturowy F5 uruchamia aplikację z debugerem dołączonym do procesu aplikacji, ale nie masz jeszcze niczego specjalnego do zbadania w kodzie. Aplikacja po prostu ładuje się i zobaczysz dane wyjściowe konsoli:

   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
   

   W dalszej części samouczka przyjrzysz się bliżej tej aplikacji w debugerze i zapoznasz się z innymi funkcjami debugowania.

2. Zatrzymaj debugger, wybierając pozycję Zatrzymaj (ikona czerwonego kwadratu) na pasku narzędzi debugowania. Możesz również użyć skrótu klawiaturowego Shift + F5.

3. W oknie konsoli uruchomionej aplikacji wybierz dowolny klucz, a następnie wybierz pozycję Wprowadź, aby zamknąć okno.

Ustawianie punktu przerwania i uruchamianie debugera

Spróbuj ustawić punkt przerwania i wstrzymywać go w wybranym punkcie w debugerze:

1. Wróć do get-started-debugging.cpp pliku w edytorze kodu i znajdź pętlę formain funkcji:

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

2. Ustaw punkt przerwania w wierszu zawierającym instrukcję kodu name += letters[i];, wybierając linię w lewym marginesie. Program Visual Studio dodaje czerwony okrąg o wartości w marginesie, aby wskazać ustawiony punkt przerwania.

   Napiwek

   Możesz również umieścić kursor w wierszu kodu i wybrać pozycję F9, aby przełączyć punkt przerwania dla tego wiersza.

   Punkty przerwania są jedną z najbardziej podstawowych i podstawowych funkcji niezawodnego debugowania. Punkt przerwania wskazuje, gdzie program Visual Studio ma zawiesić uruchomiony kod. Po wstrzymaniu wykonywania możesz przyjrzeć się wartościom zmiennych, sprawdzić zachowanie pamięci lub sprawdzić, czy jest uruchamiana gałąź kodu.

3. Uruchom aplikację w debugerze, wybierając pozycję F5 lub Rozpocznij debugowanie.

   Program Visual Studio rozpoczyna wykonywanie aplikacji. Gdy debuger osiągnie ustawiony punkt przerwania, proces debugowania zostanie wstrzymany.

   Program Visual Studio dodaje żółtą strzałkę do czerwonego okręgu punktu przerwania w marginesie, aby reprezentować instrukcję kodu, w którym debuger został zatrzymany. Wykonywanie programu jest wstrzymane i wskazana instrukcja oczekuje na przetworzenie.

   

   Notatka

   Akcja F5 odnosi się do bieżącego stanu wykonywania aplikacji. Jeśli aplikacja nie jest uruchomiona i wybierzesz F5, debuger uruchamia aplikację i kontynuuje wykonywanie, dopóki nie osiągnie pierwszego ustawionego punktu przerwania. To zachowanie przypisuje się do polecenia Debug>Rozpocznij debugowanie. Jeśli aplikacja jest już uruchomiona i wybierzesz pozycję F5, wykonywanie aplikacji będzie kontynuowane, dopóki debuger nie osiągnie następnego punktu przerwania lub zakończenia programu. To zachowanie odpowiada poleceniu „Debug>Kontynuuj”.

Punkty przerwania to przydatna funkcja, gdy znasz wiersz kodu lub sekcję kodu, którą chcesz szczegółowo zbadać. Aby uzyskać informacje na temat różnych typów punktów przerwania, które można ustawić, takich jak warunkowe punkty przerwania, zobacz Użyj odpowiedniego typu punktu przerwania.

Przechodź przez kod w debugerze

Wygodnym sposobem przeglądania kodu w debugerze jest użycie komend krokowych. Te polecenia umożliwiają przechodzenie do, krok po krokui sekcji kodu, a także krok wstecz wykonywania aplikacji.

Poniższa procedura podkreśla, jak używać skrótów klawiaturowych z poleceniami do krokowego wykonywania, aby szybko przechodzić przez kod. (Równoważne akcje menu są wyświetlane w nawiasach).

1. Uruchom aplikację w debugerze, wybierając pozycję F5 lub Rozpocznij debugowanie.

2. Podczas gdy debuger jest wstrzymany w pętli for w funkcji main, wybierz pozycję F11 (Debugowanie > Krok do) dwa razy, aby przejść do wywołania metody SendMessage.

   Po dwukrotnym wybraniu F11, kontynuowane jest wykonywanie instrukcji kodu SendMessage(name, a[i]);.

3. Ponownie wybierz F11, aby przejść do metody SendMessage.

   Zwróć uwagę, że żółty wskaźnik przechodzi do metody SendMessage:

   

   Skrót klawiaturowy F11 inicjuje polecenie Step Into, które powoduje postęp wykonywania aplikacji po jednej instrukcji naraz. Jest to dobry sposób, aby w najbardziej szczegółowy sposób zbadać przepływ wykonania. Domyślnie debuger pomija kod nieużytkownika. Aby uzyskać więcej informacji, zobacz Just My Code. W dalszej części samouczka nauczysz się, jak szybciej przechodzić przez kod.

4. Po zbadania metody SendMessage możesz kontynuować debugowanie za pomocą polecenia Step Out. Wybierz pozycję Shift + F11 (Debug > Wyjdź).

   To polecenie wznawia wykonywanie aplikacji (i kontynuuje działanie debugera) do momentu zakończenia działania bieżącej metody lub funkcji.

   Po zakończeniu polecenia debuger zatrzymuje się w pętli for w metodzie main przy wywołaniu metody SendMessage.

5. Wybierz F11 kilka razy, aż powrócisz ponownie do wywołania metody SendMessage.

6. Podczas wstrzymania debugera przy wywołaniu metody wybierz F10 (Debug > Przejdź przez).

   

   Zauważ, że tym razem debuger nie przechodzi do metody SendMessage. Skrót F10 przesuwa debuger bez wchodzenia do funkcji czy metod w kodzie aplikacji (kod nadal jest wykonywany). Po wybraniu F10 wywołania metody SendMessage (zamiast F11) kod implementacji dla SendMessage. Takie podejście przydaje się do pomijania kodu, którego nie trzeba obecnie sprawdzać. Aby uzyskać więcej informacji na temat różnych sposobów przechodzenia przez kod, zobacz Nawigacja po kodzie w debugerze.

Przeglądaj kod za pomocą funkcji Run to Click

Innym sposobem pracy z kodem w debugerze jest użycie funkcji Uruchom, aby kliknąć. Ta akcja jest podobna do ustawiania tymczasowego punktu przerwania.

Kontynuuj sesję debugowania:

1. Wybierz pozycję F5, aby przejść do punktu przerwania w kodzie.

2. W edytorze kodu przewiń do definicji metody SendMessage i umieść kursor na funkcji std::wcout.

   Najedź kursorem, aż Run to Click (ikona zielonej strzałki) pojawi się po lewej stronie kodu. Jeśli umieścisz wskaźnik myszy na ikonie, zobaczysz etykietkę narzędzia "Uruchom wykonywanie tutaj":

   

3. Wybierz Uruchom, aby kliknąć.

   Debugger doprowadza wykonanie do wskazanej pozycji. W tym przykładzie debuger osiąga wywołanie funkcji std::wcout.

Akcja Uruchom do kliknięcia jest przydatna do szybkiej nawigacji w obrębie widocznego regionu kodu aplikacji. Możesz użyć tej funkcji w dowolnym pliku otwartym w edytorze kodu.

Szybkie ponowne uruchamianie aplikacji

Szybko uruchom ponownie aplikację, wybierając pozycję Uruchom ponownie (ikona strzałki cyklicznej) na pasku narzędzi debugowania. Możesz również wybrać Debugowanie > Uruchom ponownie lub użyć skrótu klawiaturowego Ctrl + Shift + F5.

Funkcja Uruchom ponownie jest wydajniejsza niż zatrzymywanie aplikacji i ponowne uruchamianie debugera.

Po wybraniu Uruchom ponowniedebuger wstrzymuje się w pierwszym punkcie przerwania, na który natrafi podczas wykonywania. W tym przykładzie debuger zatrzymuje się ponownie w punkcie przerwania ustawionym wewnątrz pętli for.

Sprawdzanie zmiennych za pomocą porad dotyczących danych

Funkcje, które ułatwiają sprawdzanie zmiennych, są jedną z najbardziej przydatnych zalet pracy z debugerem. Często podczas debugowania problemu próbujesz ustalić, czy zmienne przechowują oczekiwane wartości w określonych godzinach. Program Visual Studio udostępnia kilka sposobów, aby ułatwić wykonanie tego zadania.

Kontynuuj sesję debugowania:

1. Podczas gdy debuger jest wstrzymany w instrukcji name += letters[i], umieść kursor na zmiennej letters. Wybierz strzałkę rozwijania/zwijania po lewej stronie nazwy zmiennej i wyświetl jej właściwości w menu wysuwany.

   Funkcja wskazówek dotyczących danych pokazuje wszystkie elementy, które zawiera zmienna. Zwróć uwagę na wartość domyślną size={10}:

   

2. Następnie umieść kursor na zmiennej name i zwróć uwagę na jej bieżącą wartość, pusty ciąg ("").

3. Wybierz F5 (Debug>Kontynuuj) kilkakrotnie, aby wielokrotnie przejść przez pętlę for. Za każdym razem, gdy debuger wstrzymuje się w punkcie przerwania, umieść kursor na zmiennej name i sprawdź bieżącą wartość:

   

   Wartość zmiennej zmienia się wraz z każdą iterację pętli for, pokazując wartości f, a następnie fr, a następnie freitd.

Sprawdzanie zmiennych za pomocą okien Autos i Locals

Innym podejściem do sprawdzania zmiennych i wartości jest użycie okien Autos i Locals. Domyślnie te okna są wyświetlane poniżej edytora kodu w środowisku IDE programu Visual Studio podczas debugowania aplikacji:

1. Zwróć uwagę na okno Autos poniżej edytora kodu.

   Jeśli nie widzisz okna podczas sesji debugowania, wybierz pozycję Debugowanie>Windows>Autos, aby otworzyć okno.

   W oknie Autos są wyświetlane wszystkie zmienne używane w bieżącym wierszu lub poprzednim wierszu wraz z ich bieżącą wartością. Należy pamiętać, że określone języki programowania mogą demonstrować unikatowe zachowanie zmiennych i właściwości. Aby uzyskać więcej informacji, zobacz wskazówki dotyczące języka Visual Studio.

2. Następnie zapoznaj się z oknem Lokale. Domyślnie to okno jest wyrównane obok okna Autos.

   Jeśli nie widzisz okna podczas sesji debugowania, wybierz pozycję Debugowanie>>Ustawienia lokalne systemu Windows, aby otworzyć okno

3. W oknie Locals rozwiń zmienną letters, aby wyświetlić elementy, które zawiera.

   

   W oknie Locals są wyświetlane zmienne, które znajdują się w bieżącym zakresie , czyli bieżącym kontekście wykonywania.

Obserwowanie zmiennej

Jeśli interesuje Cię obserwowanie zachowania określonej zmiennej, możesz ustawić zegarek :

W edytorze kodu kliknij prawym przyciskiem myszy zmienną name i wybierz pozycję Dodaj zegarek. Okno Watch zostanie otwarte poniżej edytora kodu. Możesz użyć okna Watch, aby określić zmienną (lub wyrażenie), które chcesz śledzić.

Podczas oglądania zmiennej name podczas wykonywania aplikacji w debugerze można zobaczyć jego zmianę wartości. W przeciwieństwie do innych okien zmiennych, w oknie Watch zawsze są wyświetlane zmienne, które obserwujesz. Gdy obserwowana zmienna nie jest widoczna, jej nazwa jest wyblakła.

Badanie stosu wywołań

Okno Stos wywołań w programie Visual Studio pokazuje kolejność wywoływania metod i funkcji. To okno jest podobne do perspektywy debugowania w niektórych środowiskach IDE, takich jak Eclipse. Domyślnie stos wywołań jest widoczny w prawym dolnym okienku podczas sesji debugowania poniżej edytora kodu.

1. Podczas gdy debuger jest wstrzymany w pętli for, wybierz okno stosu wywołań, aby zobaczyć obecną strukturę wywołań.

   Jeśli podczas sesji debugowania nie widzisz okna, wybierz Debug>Windows>Stos wywołań, aby otworzyć okno.

2. Wybierz pozycję F11 (Debugowanie>Krok do) kilka razy, aż zobaczysz wstrzymanie debugera w metodzie SendMessage.

3. Ponownie zapoznaj się z oknem stosu wywołań:

   

   W oknie stosu wywołań, górny wiersz przedstawia bieżącą funkcję (metodę SendMessage w tej aplikacji). Drugi wiersz pokazuje, że metoda SendMessage została wywołana z metody main itd.

Stos wywołań to dobry sposób na sprawdzenie i zrozumienie przepływu wykonywania aplikacji:

• Kliknij dwukrotnie wiersz kodu, aby przejść do kodu źródłowego. Ta akcja zmienia również bieżący zakres kontrolowany przez debuger, ale nie przesuwa działania debugera naprzód.
• Uzyskaj dostęp do menu prawym przyciskiem myszy dla elementów programowania w oknie stosu wywołań. Można na przykład wstawić punkty przerwania do określonych funkcji, wznowić działanie debugera przy użyciu polecenia Uruchom do kursorai przeglądać kod źródłowy. Aby uzyskać więcej informacji, zobacz Wyświetl stos wywołań i użyj okna stosu wywołań w debugerze.

Zmień przepływ wykonywania

Kolejną zaawansowaną funkcją debugera jest możliwość modyfikowania przepływu wykonywania podczas debugowania:

1. Wybierz pozycję F11 (Debugowanie>Krok do), aby uruchomić funkcję std::wcout.

2. Podczas gdy debuger jest wstrzymany w wywołaniu metody SendMessage, zaznacz i przeciągnij żółtą strzałkę (wskaźnik wykonywania) z lewej strony zmiennej i przenieś strzałkę do poprzedniej instrukcji kodu, std::wcout.

3. Ponownie wybierz F11.

   Debuger ponownie uruchamia funkcję std::wcout. Proces można śledzić w danych wyjściowych terminalu.

   Zmieniając przepływ wykonywania, można wykonywać takie czynności, jak testowanie różnych ścieżek wykonywania kodu lub ponowne uruchamianie kodu bez ponownego uruchamiania debugera.

   Ostrożność

   Należy zwrócić szczególną uwagę podczas pracy z tą funkcją. Po wybraniu żółtej strzałki program Visual Studio wyświetli ostrzeżenie w etykietce narzędzia wskazujące, że zmiana sposobu wykonania może mieć niezamierzone konsekwencje. Możesz również zobaczyć inne ostrzeżenia w zależności od scenariusza. Pamiętaj, że przeniesienie wskaźnika nie może przywrócić aplikacji do wcześniejszego stanu aplikacji.

4. Wybierz pozycję F5, aby ukończyć wykonywanie aplikacji.

Przekazywanie argumentów wiersza polecenia

Ustaw argumenty wiersza polecenia dla aplikacji we właściwościach projektu. Jest to przydatne, gdy chcesz przetestować działanie aplikacji przy użyciu różnych argumentów wiersza polecenia.

Począwszy od programu Visual Studio 2026, możesz ustawić argumenty wiersza polecenia dla aplikacji na liście rozwijanej pasek narzędzi argumentów wiersza polecenia. Ta funkcja jest dostępna dla projektów Visual Studio C++, projektów Unreal Engine .uproject i projektów CMake. Jest ona obecnie dostępna w wersji zapoznawczej i może ulec zmianie przed ostatecznym wydaniem.

Zmodyfikuj aplikację, aby akceptowała argumenty wiersza polecenia, zastępując kod w get-started-debugging.cpp pliku następującym kodem:

#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;
}

Ta zaktualizowana wersja aplikacji akceptuje argument /u wiersza polecenia, który konwertuje nazwę na wielkie litery przed jego wyprowadzeniem.

Aby przekazać /u argument wiersza polecenia do aplikacji podczas uruchamiania debugowania, wykonaj następujące kroki:

1. Na pasku narzędzi w warstwie Standardowa pole tekstowe Argumenty wiersza polecenia wpisz /u:

   

2. Umieść punkt przerwania w wierszu 19 , uppercase = true;klikając lewą rynnę w tym wierszu.

   

3. Rozpocznij debugowanie aplikacji, wybierając przycisk Rozpocznij debugowanie lub naciskając F5.

4. Debuger osiąga punkt przerwania, ponieważ /u został przekazany jako argument wiersza polecenia:

   

5. Wybierz F5 , aby kontynuować uruchamianie aplikacji. Dane wyjściowe w oknie konsoli zawierają teraz nazwy w wielkiej litery:

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

Argumenty wiersza polecenia są zapisywane na liście rozwijanej w kolejności ich wprowadzania i pojawiają się na liście rozwijanej do użycia w przyszłości. Istnieje limit pięciu wierszy poleceń, które można dodać przed usunięciem najstarszego, aby zrobić miejsce dla nowego.

Możesz wybrać strzałkę listy rozwijanej, aby wyświetlić listę wcześniej używanych argumentów wiersza polecenia.

Przekazywanie argumentów wiersza polecenia w różnych typach projektów

Lista rozwijana argumentów wiersza polecenia zawiera opcję specyficzną dla typu projektu, aby otworzyć klasyczny sposób ustawiania argumentów, które debuger przekazuje do programu. W przypadku .vcxproj projektów jest to strona właściwości ustawień projektu. W przypadku projektów CMake jest to edytowanie vs.launch.json pliku. W przypadku projektów Unreal Engine jest to edytowanie .uproject pliku.

Typ projektu programu Visual Studio (.vcxproj)

W projekcie programu Visual Studio (.vcxproj) zostanie wyświetlona opcja na liście rozwijanej Argumenty wiersza polecenia, aby edytować na stronach właściwości:

Wybierz pozycję Edytuj na stronach właściwości , aby otworzyć okno właściwości projektu na stronie właściwości Debugowanie , na której ustawiono argumenty wiersza polecenia, które mają być przekazywane podczas debugowania aplikacji:

Zmiany argumentów poleceń są odzwierciedlane na liście rozwijanej argumenty wiersza polecenia dla przyszłych sesji debugowania.

Typ projektu CMake

W przypadku projektów CMake na liście rozwijanej Argumenty wiersza polecenia zostanie wyświetlona opcja Edytuj w launch.vs.jsonpliku :

Wybierz pozycję Edytuj w launch.vs.jsonpliku , aby otworzyć launch.vs.json plik i ustawić argumenty wiersza polecenia, które mają być przekazywane podczas debugowania aplikacji w elememencie "args" :

Zmiany w pliku są odzwierciedlane na liście rozwijanej argumentów wiersza polecenia dla przyszłych sesji debugowania.

Typ projektu Unreal Engine (.uproject)

W przypadku projektów Unreal Engine na liście rozwijanej Argumenty wiersza polecenia zostanie wyświetlona opcja Edytuj w UETargetProperties.jsonpliku :

Wybierz pozycję Edytuj w UETargetProperties.jsonpliku , aby otworzyć UETargetProperties.json plik, w którym ustawiono argumenty wiersza polecenia, które mają być przekazywane podczas debugowania aplikacji w elememencie "args":

Zmiany w pliku są odzwierciedlane na liście rozwijanej argumentów wiersza polecenia dla przyszłych sesji debugowania.

Powiązana zawartość

• Pierwsze spojrzenie na debugger Visual Studio
• nawigowanie po kodzie przy użyciu debugera programu Visual Studio
• Użyj odpowiedniego typu punktu przerwania (.NET, .NET Framework, C++, Wszystkie języki)