Självstudie: Felsök C++-kod med Visual Studio

I den här självstudien felsöker du ett C++-program med hjälp av Visual Studio-felsökningsprogrammet. När du felsöker ett program kör du vanligtvis din app med felsökningsprogrammet kopplat. Felsökningsprogrammet innehåller många sätt att undersöka vad koden gör under programkörningen. Du kan gå igenom koden och titta på värden som lagras i variabler och ange klockor på variabler för att se när värdena ändras. Felsökningsprogrammet hjälper dig att undersöka körvägen för din kod och bekräfta att en viss del av koden exekveras.

I den här handledningen:

Om du är nybörjare på felsökning kanske du vill läsa Felsökning för absoluta nybörjare innan du påbörjar den här självstudien. Om du vill ha en vy på högre nivå över felsökningsfunktionerna kan du läsa Titta först på felsökningsprogrammet.

Förutsättningar

• Visual Studio 2022 version 17.12 eller senare med Desktop-utveckling med C++ arbetsbelastning installerad.

  • Om du vill installera Visual Studio kostnadsfritt går du till sidan Visual Studio-nedladdningar.
  • Om du vill installera Visual Studio kostnadsfritt går du till sidan versions- och versionshistorik om du vill veta mer.

  • Om du redan har Visual Studio kan du installera arbetsbelastningen från IDE (Interactive Development Environment):

    1. Välj Verktyg>Hämta verktyg och funktioner.
    2. I Visual Studio Installern väljer du fliken arbetslaster.
    3. Välj Desktop-utveckling med C++ arbetsbelastning och välj sedan Ändra.
    4. Följ anvisningarna och slutför installationen.

• I den här självstudien används ett C++-demoprogram och skärmbilderna innehåller C++-syntax. De flesta av de demonstrerade funktionerna gäller även för C#, Visual Basic, F#, Python, JavaScript och andra språk som stöds av Visual Studio. Det finns några begränsningar att tänka på:

  • F#: Funktionen Redigera och fortsätt stöds inte.
  • F# och JavaScript: fönstret Autos stöds inte.

Skapa ett projekt

Följ de här stegen för att skapa ett C++-konsolprogramprojekt i Visual Studio. Projekttypen innehåller alla mallfiler som du behöver för att komma igång snabbt:

1. I fönstret Starta i Visual Studio (Fil>startfönster) väljer du Skapa ett nytt projekt:

   

2. Ange filtret Language till C++ och ställ in filtret Platform på Windows.

3. I rutan Search anger du -konsolenoch väljer mallen Console App i resultatlistan:

   

   

   Observera

   Om du inte ser mallen Console App kan du installera den från fönstret Skapa ett nytt projekt. Leta upp Hittar du inte det du letar efter? avsnittet som följer sökresultaten och välj Installera fler verktyg och funktioner. I Visual Studio Installer väljer du Desktop-utveckling med C++ arbetsbelastning och uppdaterar installationen. Mer information finns i avsnittet Krav.

4. Välj Nästa för att fortsätta till konfigurationssidan.

5. Ange get-started-debugging som projektnamn och lösningsnamn för den nya appen. Välj standard Plats eller bläddra till en annan sökväg i din miljö.

6. Välj Skapa för att skapa det nya Node.js projektet.

Visual Studio skapar ditt nya projekt och öppnar projekthierarkin i Solution Explorer. Filen get-started-debugging.cpp är öppen i kodredigeraren.

Skapa programmet

Skapa ett nytt program för projektet genom att redigera get-started-debugging.cpp filen i kodredigeraren.

Ersätt standardinnehållet som tillhandahålls av mallen med följande kod:

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

Starta felsökningsprogrammet

Nu är du redo att börja felsöka den uppdaterade koden:

1. Starta felsökningssessionen genom att välja F5 eller Felsökning > Starta felsökning. Du kan också välja Starta felsökning (rödgrön pilikon) i verktygsfältet Felsök.

   Kortkommandot F5 startar programmet med felsökningsprogrammet kopplat till appprocessen, men du har ännu inget speciellt att undersöka i koden. Appen laddas helt enkelt, och du ser konsolutdata:

   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
   

   Senare i självstudien tittar du närmare på den här appen i felsökningsprogrammet och utforskar andra felsökningsfunktioner.

2. Stoppa felsökningsprogrammet genom att välja Stoppa (röd fyrkantsikon) i verktygsfältet Felsökning. Du kan också använda kortkommandot Shift + F5.

3. I konsolfönstret för det program som körs väljer du valfri nyckel och väljer sedan Ange för att stänga fönstret.

Ange en brytpunkt och starta felsökningsprogrammet

Prova att ange en brytpunkt och pausa vid den valda punkten i felsökningsprogrammet:

1. Gå tillbaka till get-started-debugging.cpp filen i kodredigeraren och leta reda på for funktionens main loop:

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

2. Ange en brytpunkt vid raden med kodrad name += letters[i]; genom att välja i den vänstra marginalen på raden. Visual Studio lägger till en röd cirkel i marginalen för att indikera den inställda brytpunkten.

   Tips

   Du kan också placera markören på en kodrad och välja F9 för att växla brytpunkten för den raden.

   Brytpunkter är en av de mest grundläggande och viktigaste funktionerna i tillförlitlig felsökning. En brytpunkt anger var du vill att Visual Studio ska pausa koden som körs. När körningen har pausats kan du ta en titt på värdena för variabler, undersöka minnesbeteendet eller kontrollera om en gren av koden körs.

3. Starta appen i felsökningsprogrammet genom att välja F5 eller Starta felsökning.

   Visual Studio startar körningen av din app. När debuggern når din brytpunkt pausas felsökningsprocessen.

   Visual Studio lägger till en gul pil till den röda brytpunktscirkeln i rännstenen för att representera kodsatsen där felsökningsprogrammet pausas. Programkörningen pausas och den angivna instruktionen väntar på att bearbetas.

   

   Observera

   Åtgärden F5 är relativ till det aktuella exekveringstillståndet för din applikation. Om appen inte körs och du väljer F5startar felsökningsprogrammet appen och fortsätter att köras tills den når den första brytpunkten. Det här beteendet mappar till kommandot Debug>Start Debugging. Om appen redan körs och du väljer F5fortsätter appkörningen tills felsökningsprogrammet når nästa brytpunkt eller slut på programmet. Det här beteendet mappar till kommandot Debug>Fortsätt.

Brytpunkter är en användbar funktion när du känner till kodraden eller kodavsnittet som du vill undersöka i detalj. Information om de olika typer av brytpunkter som du kan ange, till exempel villkorliga brytpunkter, finns i Använd rätt typ av brytpunkt.

Stega igenom koden i felsökningsprogrammet

Ett praktiskt sätt att bläddra i koden i felsökningsprogrammet är att använda stegkommandon. Med de här kommandona kan du Stega in i, Stega över, och Stega ut i ett kodavsnitt, och även Stega bakåt i appens körning.

Följande procedur belyser hur du använder kortkommandon med stegkommandon för att snabbt arbeta igenom koden. (Motsvarande menyåtgärder visas inom parentes.)

1. Starta appen i felsökningsprogrammet genom att välja F5 eller Starta felsökning.

2. När felsökningsprogrammet har pausats i for-loopen i funktionen main väljer du F11 (Felsök > Steg in i) två gånger för att gå vidare till SendMessage-metodanropet.

   När du har valt F11 två gånger fortsätter exekveringen till kodstycket SendMessage(name, a[i]);.

3. Välj F11 igen för att gå in i metoden SendMessage.

   Observera att den gula pekaren avancerar till metoden SendMessage:

   

   Kortkommandot F11 initierar kommandot Steg In, vilket framskjuter exekveringen av appen en instruktion i taget. Det är ett bra sätt att studera exekveringsflödet i detalj. Som standard hoppar felsökningsprogrammet över kod som inte är använda. Mer information finns i Just My Code. Senare i handledningen får du lära dig sätt att snabbt gå igenom din kod.

4. När du har undersökt metoden SendMessage kan du fortsätta felsökningen med kommandot Step Out. Välj Skift + F11 (Felsök > Step Out).

   Det här kommandot återupptar appkörningen (och avancerar felsökningsprogrammet) tills den aktuella metoden eller funktionen returnerar.

   När kommandot har slutförts pausar felsökningsprogrammet i for-loopen för main-metoden vid SendMessage-metodanropet.

5. Välj F11 flera gånger tills du återgår till SendMessage-metodanropet igen.

6. När felsökningsprogrammet pausas vid metodanropet väljer du F10 (Felsöka > Steg över).

   

   Observera den här gången att felsökaren inte går in i metoden SendMessage. Genvägen F10 avancerar felsökningsprogrammet utan att gå in på funktioner eller metoder i appkoden (koden körs fortfarande). När du väljer F10 på SendMessage-metodanropet (i stället för F11) du Steg över implementeringskoden för SendMessage. Den här metoden är användbar för att gå förbi kod som du inte behöver inspektera för närvarande. Mer information om olika sätt att gå igenom koden finns i Navigera kod i felsökningsprogrammet.

Bläddra i koden med Kör för att klicka

Ett annat sätt att arbeta igenom koden i felsökningsprogrammet är med funktionen Kör för att klicka på. Den här åtgärden liknar inställningen av en tillfällig brytpunkt.

Fortsätt med felsökningssessionen:

1. Välj F5 för att gå vidare till brytpunkten i koden.

2. Rulla till SendMessage-metoddefinitionen i kodredigeraren och hovra över funktionen std::wcout.

   Hovra tills Kör för att klicka (grön pilikon) visas till vänster om kodsatsen. Om du håller muspekaren över ikonen visas knappbeskrivningen "Kör hit"

   

3. Välj Kör för att klicka på .

   Felsökningsprogrammet för körningen framåt till den angivna positionen. I det här exemplet når felsökningsprogrammet anropet till funktionen std::wcout.

Åtgärden Kör för att klicka på är praktisk för att snabbt komma runt inom en synlig region med appkod. Du kan använda funktionen i valfri fil som är öppen i kodredigeraren.

Starta om appen snabbt

Starta snabbt om appen genom att välja Starta om (cirkelpilikon) i verktygsfältet Felsökning. Du kan också välja Felsöka > Starta om eller använda kortkommandot Ctrl + Skift + F5.

Funktionen Starta om är effektivare än att stoppa appen och starta felsökningsprogrammet igen.

När du väljer Starta ompausas felsökningsprogrammet vid den första brytpunkten som den stöter på under körningen. I det här exemplet stoppas felsökningsprogrammet igen vid den brytpunkt som du anger i for-loopen.

Inspektera variabler med datatips

Funktioner som hjälper dig att inspektera variabler är en av de mest användbara fördelarna med att arbeta med felsökningsprogrammet. När du felsöker ett problem försöker du ofta ta reda på om variabler lagrar förväntade värden vid vissa tidpunkter. Visual Studio innehåller flera sätt att hjälpa dig att slutföra den här uppgiften.

Fortsätt med felsökningssessionen:

1. Medan felsökningsprogrammet är pausat vid instruktionssteget name += letters[i], för muspekaren över variabeln letters. Välj pilen expandera/dölj till vänster om variabelnamnet och visa dess egenskaper på den utfällbara menyn.

   Funktionen datatips visar alla element som variabeln innehåller. Observera standardvärdet size={10}:

   

2. Hovra sedan över variabeln name och lägg märke till dess aktuella värde, en tom sträng ("").

3. Välj F5 (Felsök>Fortsätt) några gånger för att iterera flera gånger genom for-loopen. Varje gång felsökningsprogrammet pausar vid brytpunkten hovrar du över variabeln name och kontrollerar det aktuella värdet:

   

   Värdet för variabeln ändras med varje iteration av for-loopen, som visar värden för f, sedan fr, sedan freoch så vidare.

Granska variabler med fönstren Autos och Lokala

En annan metod för att inspektera variabler och värden är att använda Autos och Locals fönster. Som standard visas dessa fönster under kodredigeraren i Visual Studio IDE när du felsöker appen:

1. Observera fönstret Autos under kodredigeraren.

   Om du inte ser fönstret under felsökningssessionen väljer du Felsöka>Windows>Autos för att öppna fönstret.

   Fönstret Autos visar alla variabler som används på den aktuella raden eller föregående rad tillsammans med deras aktuella värde. Tänk på att specifika programmeringsspråk kan demonstrera unikt beteende för variabler och egenskaper. Mer information finns i Visual Studio Language Guidance.

2. Ta sedan en titt på fönstret Locals. Som standardinställning placeras det här fönstret bredvid fönstret Autos.

   Om du inte ser fönstret under felsökningssessionen väljer du Felsöka>Windows>Locals för att öppna fönstret

3. I fönstret Locals expanderar du variabeln letters för att visa de element som den innehåller.

   

   

   Fönstret Locals visar de variabler som finns i det aktuella omfånget, det vill säga den aktuella körningskontexten.

Titta på en variabel

Om du är intresserad av att titta på beteendet för en specifik variabel kan du ange en klocka:

Högerklicka på variabeln name i kodredigeraren och välj Lägg till klocka. Fönstret Watch öppnas under kodredigeraren. Du kan använda ett Watch-fönster för att ange en variabel (eller ett uttryck) som du vill spåra.

När du tittar på variabeln name under appkörningen i felsökningsprogrammet kan du se dess värde ändras. Till skillnad från de andra variabelfönstren visar fönstret Watch alltid de variabler som du tittar på. När en bevakad variabel inte finns i omfånget är variabelnamnet nedtonat.

Granska anropsstacken

Fönstret Call Stack i Visual Studio visar i vilken ordning metoder och funktioner anropas. Det här fönstret liknar felsökningsperspektivet i vissa IDE:er som Eclipse. Som standard visas anropsstacken i det nedre högra fönstret under felsökningssessionen under kodredigeraren.

1. När felsökningsprogrammet har pausats i for-loopen väljer du fönstret Anropa Stack för att se den aktuella samtalsstrukturen.

   Om du inte ser fönstret under felsökningssessionen väljer du Felsöka>Windows>Samtalsstack för att öppna fönstret.

2. Välj F11 (Felsök>Steg in i) några gånger tills felsökningsprogrammet pausas i metoden SendMessage.

3. Titta på Anropsstack-fönstret igen:

   

   

   I fönstret anropsstack visas överst den aktuella funktionen (metoden SendMessage i den här appen). Den andra raden visar att metoden SendMessage anropades från metoden main och så vidare.

Anropsstacken är ett bra sätt att undersöka och förstå körningsflödet för en app:

• Dubbelklicka på en kodrad för att bläddra till källkoden. Den här åtgärden ändrar även det aktuella omfånget under kontroll av felsökningsprogrammet, men det för inte fram felsökningsprogrammet.
• Öppna snabbmenyer för programmeringselement i fönstret anropsstack. Du kan till exempel infoga brytpunkter i angivna funktioner, avancera felsökningsprogrammet med hjälp av Kör till marköroch bläddra till källkod. Mer information finns i Visa anropsstacken och använd fönstret Anropsstack i felsökningsprogrammet.

Ändra körningsflödet

En annan kraftfull felsökningsfunktion är möjligheten att ändra körningsflödet under felsökningen:

1. Välj F11 (Felsök>Steg in i) två gånger för att köra funktionen std::wcout.

2. När felsökningsprogrammet pausas i SendMessage-metodanropet väljer du och drar den gula pilen (körningspekaren) till vänster om variabeln och flyttar pilen till föregående kodsats std::wcout.

3. Välj F11 igen.

   Felsökningsprogrammet kör funktionen std::wcout igen. Du kan spåra processen i terminalutdata.

   Genom att ändra körflödet kan du till exempel testa olika exekveringsvägar för kod eller köra om kod utan att starta om debuggern.

   Försiktighet

   Var uppmärksam när du arbetar med den här funktionen. När du väljer den gula pilen visar Visual Studio en varning i knappbeskrivningen som anger att körningsändringen kan få oavsiktliga konsekvenser. Du kan också se andra varningar, beroende på ditt scenario. Tänk på att det inte går att återställa programmet till ett tidigare apptillstånd om du flyttar pekaren.

4. Välj F5 för att slutföra appkörningen.

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

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

Relaterat innehåll

• Första titten på Visual Studio-felsökningsprogrammet
• Navigera genom kod med hjälp av Visual Studio-felsökningsprogrammet
• Använd rätt typ av brytpunkt (.NET, .NET Framework, C++, Alla språk)