Zelfstudie: Fouten opsporen in C++ code met Visual Studio

In deze zelfstudie gaat u fouten opsporen in een C++-toepassing met behulp van het Visual Studio-foutopsporingsprogramma. Wanneer u fouten in een toepassing opssport, voert u uw app meestal uit met het bijgevoegde foutopsporingsprogramma. Het foutopsporingsprogramma biedt veel manieren om te onderzoeken wat uw code doet tijdens het uitvoeren van het programma. U kunt uw code doorlopen en waarden bekijken die zijn opgeslagen in variabelen en horloges instellen op variabelen om te zien wanneer waarden veranderen. Met de debugger kunt u het uitvoeringspad van uw code bekijken en controleren of een codepad wordt uitgevoerd.

In deze zelfstudie gaat u het volgende doen:

• Start het foutopsporingsprogramma en pauzeer op onderbrekingspunten
• Leer opdrachten om code in de debugger door te lopen
• Variabelen inspecteren in gegevenstips en debugvensters
• De aanroepstack onderzoeken
• Opdrachtregelargumenten instellen voor uw toepassing

Als u nieuw bent in het opsporen van fouten, wilt u misschien Foutopsporing voor absolute beginners lezen voordat u aan deze tutorial begint. Als u een weergave op een hoger niveau van de functies van het foutopsporingsprogramma wilt, raadpleegt u Eerst het foutopsporingsprogramma.

Voorwaarden

• Visual Studio 2022 versie 17.12 of hoger met de Desktop-ontwikkeling waarop C++ workload is geïnstalleerd.

  • Als u Visual Studio gratis wilt installeren, gaat u naar de Visual Studio-downloads pagina.

  • Als u Visual Studio al hebt, kunt u de workload installeren vanuit de Interactive Development Environment (IDE):

    1. Selecteer Hulpprogramma's>Hulpprogramma's en onderdelen ophalen.
    2. Selecteer in het installatieprogramma van Visual Studio het tabblad Workloads.
    3. Selecteer de Desktop-ontwikkeling met C++ workload en selecteer vervolgens Wijzigen.
    4. Volg de aanwijzingen en voltooi de installatie.

• In deze zelfstudie wordt gebruikgemaakt van een C++-demotoepassing en de schermopnamen bevatten de C++-syntaxis. De meeste gedemonstreerde functies zijn ook van toepassing op C#, Visual Basic, F#, Python, JavaScript en andere talen die worden ondersteund door Visual Studio. Er zijn enkele beperkingen om rekening mee te houden:

  • F#-: de functie Bewerken en doorgaan wordt niet ondersteund.
  • F# en JavaScript-: het venster Autos wordt niet ondersteund.

Een project maken

Volg deze stappen om een C++-consoletoepassingsproject te maken in Visual Studio. Het projecttype bevat alle sjabloonbestanden die u nodig hebt om snel aan de slag te gaan:

1. Selecteer in het venster Start (Bestand>Startvenster) de optie Een nieuw project maken:

   

2. Stel het filter Language in op C++ en stel het filter Platform in op Windows.

3. Voer in het vak zoeken consolein en selecteer de console-app sjabloon in de lijst met resultaten:

   

   Notitie

   Als u de sjabloon Console-app niet ziet, kunt u deze installeren vanuit het Een nieuw project venster maken. Zoek de Niet vinden wat u zoekt? sectie die de zoekresultaten volgt en selecteer Meer hulpprogramma's en functies installeren. Selecteer in het Installatieprogramma van Visual Studio de Desktop-ontwikkeling met C++ workload en werk de installatie bij. Zie de sectie Vereisten voor meer informatie.

4. Selecteer Volgende om door te gaan naar de configuratiepagina.

5. Voer get-started-debugging de projectnaam en oplossingsnaam in voor uw nieuwe app. Kies de standaardlocatie locatie of blader naar een ander pad in uw omgeving.

6. Selecteer en klik op ' maken' om het nieuwe Node.js-project aan te maken.

Visual Studio maakt uw nieuwe project en opent de projecthiërarchie in Solution Explorer. Het get-started-debugging.cpp bestand is geopend in de code-editor.

De toepassing maken

Maak een nieuwe toepassing voor uw project door het get-started-debugging.cpp bestand in de code-editor te bewerken.

Vervang de standaardinhoud die door de sjabloon wordt geleverd door de volgende code:

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

Het foutopsporingsprogramma starten

U kunt nu beginnen met het opsporen van fouten in uw bijgewerkte code:

1. Start de foutopsporingssessie door F5- of Debuggen > Start Debuggente selecteren. U kunt ook Start Debugging (effen groen pijlpictogram) selecteren in de werkbalk Foutopsporing.

   Met de sneltoets F5 wordt de toepassing gestart met het foutopsporingsprogramma dat is gekoppeld aan het app-proces, maar u hebt nog niets speciaals om in de code te onderzoeken. De app wordt gewoon geladen en u ziet de console-uitvoer:

   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
   

   Verderop in de zelfstudie bekijkt u deze app in het foutopsporingsprogramma en verkent u andere functies voor foutopsporing.

2. Stop het foutopsporingsprogramma door Stop (rood vierkantspictogram) te selecteren in de werkbalk Foutopsporing. U kunt ook de sneltoets Shift + F5 gebruiken.

3. Selecteer een willekeurige sleutel in het consolevenster voor de actieve toepassing en selecteer vervolgens Enter om het venster te sluiten.

Een onderbrekingspunt instellen en het foutopsporingsprogramma starten

Probeer een breakpoint in te stellen en te pauzeren op het geselecteerde punt in de debugger.

1. Ga terug naar het get-started-debugging.cpp bestand in de code-editor en zoek de for lus van de main functie:

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

2. Stel een onderbrekingspunt in op de regel die de code-instructie bevat name += letters[i]; door in de linker rugmarge op de regel voor de instructie te selecteren. Visual Studio voegt een rode cirkel toe in de rugmarge om het ingestelde onderbrekingspunt aan te geven.

   Tip

   U kunt de cursor ook op een regel code plaatsen en F9- selecteren om het onderbrekingspunt voor die regel in te schakelen.

   Onderbrekingspunten zijn een van de meest elementaire en essentiële functies van betrouwbare foutopsporing. Een onderbrekingspunt geeft aan waar u wilt dat Visual Studio de actieve code onderbreekt. Wanneer de uitvoering is onderbroken, kunt u de waarden van variabelen bekijken, het gedrag van het geheugen onderzoeken of controleren of een vertakking van code wordt uitgevoerd.

3. Start uw app in het foutopsporingsprogramma door F5- of Start Debuggingte selecteren.

   Visual Studio start de uitvoering van uw app. Wanneer de debugger het ingestelde breekpunt bereikt, pauzeert het foutopsporingsproces.

   Visual Studio voegt een gele pijl toe aan de rode onderbrekingspuntcirkel in de rugmarge om de code-instructie weer te geven waarin het foutopsporingsprogramma wordt onderbroken. De uitvoering van het programma is onderbroken en de aangegeven instructie wacht op verwerking.

   

   Notitie

   De actie F5 is relatief ten opzichte van de huidige uitvoeringsstatus van uw toepassing. Als uw app niet wordt uitgevoerd en u F5selecteert, wordt uw app gestart en wordt de uitvoering voortgezet totdat het eerste ingestelde onderbrekingspunt is bereikt. Dit gedrag wordt toegewezen aan de Foutopsporing>Start de Foutopsporing opdracht. Als uw app al wordt uitgevoerd en u F5selecteert, wordt de uitvoering van de app voortgezet totdat het foutopsporingsprogramma het volgende onderbrekingspunt of het volgende einde van het programma bereikt. Dit gedrag wordt toegewezen aan de opdracht Fouten opsporen>Doorgaan.

Onderbrekingspunten zijn een nuttige eigenschap wanneer u de coderegel of het codegedeelte kent dat u in detail wilt bekijken. Zie Het juiste type onderbrekingspunt gebruikenvoor informatie over de verschillende typen onderbrekingspunten die u kunt instellen, zoals voorwaardelijke onderbrekingspunten.

Uw code doorlopen in het foutopsporingsprogramma

Een handige manier om door uw code in het foutopsporingsprogramma te bladeren, is door stapopdrachtente gebruiken. Met deze opdrachten kunt u Stap in, Stap overen Stap uit van een codegedeelte, en ook Stap terug tijdens de uitvoering van de app.

In de volgende procedure wordt uitgelegd hoe u sneltoetsen gebruikt met stapopdrachten om snel uw code te doorlopen. (De equivalente menuacties worden tussen haakjes weergegeven.)

1. Start uw app in het foutopsporingsprogramma door F5- of Start Debuggingte selecteren.

2. Terwijl de debugger gepauzeerd is in de lus for in de functie main, selecteert u F11 (Foutopsporing > Stap in) tweemaal om de SendMessage methode aan te roepen.

   Nadat u F11 twee keer hebt geselecteerd, gaat de uitvoering door naar de code-instructie SendMessage(name, a[i]);.

3. Selecteer F11 opnieuw om de SendMessage methode te openen.

   U ziet dat de gele aanwijzer naar de methode SendMessage gaat:

   

   De sneltoets F11 activeert de opdracht Step Into, waarmee de uitvoering van de app stap voor stap vooruitgaat, één instructie per keer. Het is een goede manier om de uitvoeringsstroom in de meeste detail te onderzoeken. In standaardinstelling wordt de niet-gebruikerscode overgeslagen door het foutopsporingsprogramma. Zie Just My Codevoor meer informatie. Verderop in de zelfstudie leert u hoe u sneller door uw code kunt navigeren.

4. Nadat u de methode SendMessage hebt bekeken, kunt u doorgaan met foutopsporing met de opdracht Step Out. Selecteer Shift + F11 (Debug > Stap Uit).

   Met deze opdracht wordt de uitvoering van de app hervat (en wordt het foutopsporingsprogramma verder uitgevoerd) totdat de huidige methode of functie wordt geretourneerd.

   Wanneer de opdracht is voltooid, pauzeert de debugger in de for loop van de main methode tijdens de aanroep van de SendMessage methode.

5. Selecteer F11 meerdere keren totdat u opnieuw terugkeert naar de aanroep van de SendMessage methode.

6. Terwijl de debugger bij de methodeaanroep is gepauzeerd, selecteer F10 (Debug > Step Over).

   

   U ziet dit keer dat het foutopsporingsprogramma niet in de SendMessage-methode stapt. De F10 snelkoppeling gaat verder met het foutopsporingsprogramma zonder dat u functies of methoden in uw app-code hoeft in te voeren (de code wordt nog steeds uitgevoerd). Wanneer u F10 selecteert in de aanroep van de SendMessage methode (in plaats van F11), u Stap over de implementatiecode voor SendMessage. Deze benadering is nuttig om voorbij te gaan aan code die u momenteel niet hoeft te inspecteren. Zie Navigate-code in het foutopsporingsprogrammavoor meer informatie over verschillende manieren om door uw code te navigeren.

Blader door uw code met Uitvoeren tot Klik

Een andere manier om uw code in het foutopsporingsprogramma te doorlopen, is met de Uitvoeren om op functie te klikken. Deze actie is vergelijkbaar met het instellen van een tijdelijk onderbrekingspunt.

Ga door met uw foutopsporingssessie:

1. Selecteer F5- om naar het onderbrekingspunt in uw code te gaan.

2. Schuif in de code-editor naar de definitie van de SendMessage methode en beweeg de muisaanwijzer over de functie std::wcout.

   Beweeg de muisaanwijzer totdat de Run to Click (groene pijlpictogram) links van de coderegel verschijnt. Als u de muisaanwijzer over het pictogram beweegt, ziet u de knopinfo 'Uitvoering hier uitvoeren':

   

3. Selecteer Uitvoeren om op te klikken.

   Het foutopsporingsprogramma verplaatst de uitvoering naar de aangegeven positie. In dit voorbeeld bereikt de debugger de aanroep naar de std::wcout-functie.

De Run to Click-actie is handig om snel binnen een zichtbaar gebied van app-code rond te bewegen. U kunt de functie gebruiken in elk bestand dat in de code-editor wordt geopend.

Uw app snel opnieuw opstarten

Herstart uw app snel door in de foutopsporingswerkbalk op Herstart (pictogram met cirkelvormige pijl) te klikken. U kunt ook Foutopsporing selecteren > opnieuw opstarten of de sneltoets Ctrl + Shift + F5 gebruiken.

De functie Opnieuw opstarten is efficiënter dan het stoppen van de app en het opnieuw starten van het foutopsporingsprogramma.

Wanneer u opnieuw opstarten selecteert, wordt het foutopsporingsprogramma onderbroken bij het eerste onderbrekingspunt dat tijdens de uitvoering optreedt. In dit voorbeeld stopt het foutopsporingsprogramma opnieuw op het onderbrekingspunt dat u in de for lus hebt ingesteld.

Variabelen inspecteren met gegevenstips

Functies waarmee u variabelen kunt inspecteren, zijn een van de handigste voordelen van het werken met het foutopsporingsprogramma. Wanneer u een probleem opspoort, probeert u vaak te achterhalen of variabelen verwachte waarden op bepaalde momenten opslaan. Visual Studio biedt verschillende manieren om u te helpen deze taak te voltooien.

Ga door met uw foutopsporingssessie:

1. Terwijl het foutopsporingsprogramma pauzeert op de instructie name += letters[i], beweegt u de muisaanwijzer over de variabele letters. Selecteer de pijl voor uitvouwen/samenvouwen links van de naam van de variabele en bekijk de eigenschappen in het flyoutmenu.

   In de gegevenstips functie worden alle elementen weergegeven die de variabele bevat. Let op de standaardwaarde, size={10}:

   

2. Beweeg vervolgens de muisaanwijzer over de variabele name en let op de huidige waarde, een lege tekenreeks ("").

3. Selecteer F5 (Fouten opsporen>Doorgaan) een paar keer om meerdere keren door de for lus te herhalen. Telkens wanneer het foutopsporingsprogramma op het onderbrekingspunt wordt onderbroken, beweegt u de muisaanwijzer over de name variabele en controleert u de huidige waarde:

   

   De waarde van de variabele verandert met elke iteratie van de for lus, met waarden van f, fr, freenzovoort.

Variabelen inspecteren met de vensters Auto's en Locals

Een andere benadering voor het inspecteren van variabelen en waarden is het gebruik van de Autos en Locals vensters. Deze vensters worden standaard weergegeven onder de code-editor in de Visual Studio IDE terwijl u fouten in uw app opspoort:

1. Let op het venster Autos onder de code-editor.

   Als u het venster niet ziet tijdens de foutopsporingssessie, selecteert u Foutopsporing>Windows>Automatisch om het venster te openen.

   In het venster Autos worden alle variabelen weergegeven die op de huidige regel of de voorgaande regel worden gebruikt, samen met de huidige waarde. Houd er rekening mee dat specifieke programmeertalen uniek gedrag kunnen demonstreren voor variabelen en eigenschappen. Zie de Visual Studio Language Guidancevoor meer informatie.

2. Bekijk vervolgens het Locals venster. Dit venster wordt standaard uitgelijnd naast het venster Autos.

   Als u het venster niet ziet tijdens de foutopsporingssessie, selecteert u Foutopsporing>Windows>Locals om het venster te openen

3. Vouw in het venster Locals de variabele letters uit om de elementen weer te geven die deze bevat.

   

   In het venster Locals ziet u de variabelen die zich in het huidige bereikbevinden, dat wil gezegd de huidige uitvoeringscontext.

Een variabele bekijken

Als u geïnteresseerd bent in het bekijken van het gedrag van een specifieke variabele, kunt u een horloge instellen:

Klik in de code-editor met de rechtermuisknop op de variabele name en selecteer Watch toevoegen. Het venster Watch wordt geopend onder de code-editor. U kunt een venster Watch gebruiken om een variabele (of een expressie) op te geven die u wilt bijhouden.

Terwijl u de variabele name bekijkt tijdens het uitvoeren van de app in het foutopsporingsprogramma, ziet u de waardewijziging. In tegenstelling tot de andere variabelevensters worden in het venster Watch altijd de variabelen weergegeven die u bekijkt. Wanneer een gevolgde variabele niet binnen het bereik valt, wordt de naam van de variabele grijs weergegeven.

De aanroepstack onderzoeken

In het venster Aanroepstack in Visual Studio ziet u de volgorde waarin methoden en functies worden aangeroepen. Dit venster is vergelijkbaar met het perspectief foutopsporing in sommige IDE's, zoals Eclipse. De aanroepstack is standaard zichtbaar in het deelvenster rechtsonder tijdens de debugsessie onder de code-editor.

1. Terwijl de debugger gepauzeerd is in de for lus, selecteert u het venster Aanroepstack om de huidige aanroepstructuur te zien.

   Als u het venster niet ziet tijdens de debuggen sessie, selecteert u Debuggen>Windows>Aanroepstack om het venster te openen.

2. Selecteer F11 (Debuggen>Stap In) een paar keer totdat de debugger pauzeert in de methode SendMessage.

3. Bekijk het venster Call Stack opnieuw:

   

   In het venster Aanroepstack toont de bovenste lijn de huidige functie (de SendMessage methode in deze app). Op de tweede regel ziet u dat de methode SendMessage is aangeroepen vanuit de main methode, enzovoort.

De aanroepstack is een goede manier om de uitvoeringsstroom van een app te onderzoeken en te begrijpen:

• Dubbelklik op een coderegel om naar de broncode te bladeren. Met deze actie wordt ook het huidige bereik gewijzigd dat wordt gecontroleerd door het foutopsporingsprogramma, maar wordt het foutopsporingsprogramma niet verder uitgevoerd.
• Krijg toegang tot rechtermuisknopmenu's voor programmeerelementen in het Aanroepstack venster. U kunt bijvoorbeeld onderbrekingspunten invoegen in opgegeven functies, het foutopsporingsprogramma verder laten gaan met behulp van Uitvoeren naar Cursoren naar de broncode bladeren. Voor meer informatie, zie De aanroepstack weergeven en het venster aanroepstack gebruiken in het foutopsporingsprogramma.

De uitvoeringsstroom wijzigen

Een andere krachtige foutopsporingsprogrammafunctie is de mogelijkheid om de uitvoeringsstroom te wijzigen tijdens foutopsporing:

1. Selecteer tweemaal F11 (Foutopsporing>Stap in) om de functie std::wcout uit te voeren.

2. Terwijl het foutopsporingsprogramma is onderbroken in de aanroep van de methode SendMessage, selecteert en sleept u de gele pijl (de uitvoeringsaanwijzer) links van de variabele en verplaatst u de pijl naar de vorige code-instructie, std::wcout.

3. Selecteer F11 opnieuw.

   Het foutopsporingsprogramma voert de functie std::wcout opnieuw uit. U kunt het proces bijhouden in de terminaluitvoer.

   Door de uitvoeringsstroom te wijzigen, kunt u bijvoorbeeld verschillende codeuitvoeringspaden testen of code opnieuw uitvoeren zonder het foutopsporingsprogramma opnieuw te starten.

   Voorzichtigheid

   Let goed op wanneer u met deze functie werkt. Wanneer u de gele pijl selecteert, wordt in Visual Studio een waarschuwing weergegeven in de knopinfo die aangeeft dat de uitvoeringswijziging onbedoelde gevolgen kan hebben. Mogelijk ziet u ook andere waarschuwingen, afhankelijk van uw scenario. Houd er rekening mee dat het verplaatsen van de aanwijzer uw toepassing niet kan terugzetten naar een eerdere app-status.

4. Selecteer F5- om de uitvoering van de app te voltooien.

Opdrachtregelargumenten doorgeven

Stel opdrachtregelargumenten in voor uw toepassing in projecteigenschappen. Dit is handig als u wilt testen hoe uw app zich gedraagt met verschillende opdrachtregelargumenten.

Vanaf Visual Studio 2026 kunt u opdrachtregelargumenten voor uw toepassing instellen in de vervolgkeuzelijst met opdrachtregelargumenten. Deze functie is beschikbaar voor Visual Studio C++-projecten, Unreal Engine-projecten .uproject en CMake-projecten. Het is momenteel in preview en kan vóór de definitieve release worden gewijzigd.

Wijzig de toepassing om opdrachtregelargumenten te accepteren door de code in het get-started-debugging.cpp bestand te vervangen door het volgende:

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

Deze bijgewerkte versie van de toepassing accepteert een opdrachtregelargument /u dat de naam converteert naar hoofdletters voordat deze wordt uitgevoerd.

Voer de volgende stappen uit om het /u opdrachtregelargument door te geven aan de toepassing wanneer u de foutopsporing start:

1. Typ in de werkbalk Standaard het tekstvak Opdrachtregelargumenten:/u

   

2. Plaats een onderbrekingspunt op regel 19 door uppercase = true;op de linkergoot op die lijn te klikken.

   

3. Start de foutopsporing van uw toepassing door de knop Foutopsporing starten te selecteren of op F5 te drukken.

4. Het foutopsporingsprogramma raakt het onderbrekingspunt omdat /u is doorgegeven als een opdrachtregelargument:

   

5. Selecteer F5 om door te gaan met het uitvoeren van de toepassing. De uitvoer in het consolevenster toont nu de namen in hoofdletters:

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

Opdrachtregelargumenten worden opgeslagen in de vervolgkeuzelijst in de volgorde waarin u deze invoert en worden weergegeven in de vervolgkeuzelijst voor toekomstig gebruik. Er is een limiet van vijf opdrachtregels die u kunt toevoegen voordat de oudste wordt verwijderd om ruimte te maken voor de nieuwe.

U kunt de vervolgkeuzepijl selecteren om een lijst met eerder gebruikte opdrachtregelargumenten weer te geven.

Opdrachtregelargumenten doorgeven in verschillende projecttypen

De vervolgkeuzelijst met opdrachtregelargumenten bevat een projecttypespecifieke optie om de klassieke manier te openen om de argumenten in te stellen die het foutopsporingsprogramma doorgeeft aan uw programma. Voor .vcxproj projecten vindt u dit via de eigenschappenpagina van de projectinstellingen. Voor CMake-projecten is het door het vs.launch.json bestand te bewerken. Voor Unreal Engine-projecten is het door het .uproject bestand te bewerken.

Visual Studio-projecttype (.vcxproj)

In een Visual Studio-project (.vcxproj) wordt een optie weergegeven in de vervolgkeuzelijst met opdrachtregelargumenten om te bewerken in eigenschappenpagina's:

Selecteer Bewerken in eigenschappenpagina's om het venster met projecteigenschappen te openen op de eigenschappenpagina Foutopsporing , waar u opdrachtregelargumenten instelt die moeten worden doorgegeven bij het opsporen van fouten in uw toepassing:

Wijzigingen in de opdrachtargumenten worden weergegeven in de vervolgkeuzelijst met opdrachtregelargumenten voor toekomstige foutopsporingssessies.

CMake-projecttype

Voor CMake-projecten wordt een optie weergegeven in de vervolgkeuzelijst met opdrachtregelargumenten om te bewerken in launch.vs.json:

Selecteer Bewerken in launch.vs.json, om het launch.vs.json bestand te openen en opdrachtregelargumenten in te stellen die moeten worden doorgegeven bij het opsporen van fouten in uw toepassing in het "args" element:

Wijzigingen in het bestand worden doorgevoerd in de vervolgkeuzelijst met opdrachtregelargumenten voor toekomstige foutopsporingssessies.

Projecttype Unreal Engine (.uproject)

Voor Unreal Engine-projecten wordt een optie weergegeven in de vervolgkeuzelijst met opdrachtregelargumenten om te bewerken in UETargetProperties.json:

Selecteer Bewerken in UETargetProperties.json, om het UETargetProperties.json bestand te openen waarin u opdrachtregelargumenten instelt die moeten worden doorgegeven bij het opsporen van fouten in uw toepassing in het element 'args':

Wijzigingen in het bestand worden doorgevoerd in de vervolgkeuzelijst met opdrachtregelargumenten voor toekomstige foutopsporingssessies.

Verwante inhoud

• Bekijk eerst het Visual Studio-foutopsporingsprogramma
• Navigeer door code met behulp van het Visual Studio-foutopsporingsprogramma
• Het juiste type onderbrekingspunt (.NET, .NET Framework, C++, Alle talen) gebruiken