Tutorial: Depuración de código de C++ con Visual Studio

En este artículo se presentan las características del depurador de Visual Studio en un tutorial paso a paso. Al depurar una aplicación, normalmente se ejecuta la aplicación con el depurador asociado. El depurador proporciona muchas maneras de examinar lo que hace el código durante la ejecución del programa. Puede recorrer el código y examinar los valores almacenados en variables y establecer relojes en variables para ver cuándo cambian los valores. El depurador le ayuda a examinar la ruta de ejecución de tu código y confirmar que se está ejecutando un segmento del código.

En este tutorial, tú:

• Iniciar el depurador y pausarlo en puntos de interrupción
• Aprenda los comandos para avanzar paso a paso por el código en el depurador
• Inspeccionar variables en la información sobre datos y las ventanas del depurador
• Examinar la pila de llamadas

Si es la primera vez que depura, puede que quiera leer Depuración desde el principio antes de iniciar este tutorial. Si desea una visión general de las funcionalidades del depurador, consulte Primer vistazo al depurador.

Prerrequisitos

• Visual Studio 2022, versión 17.12 o posterior, con la carga de trabajo Desarrollo de escritorio con C++ instalada.

  • Para instalar Visual Studio 2022 de forma gratuita, vaya a la página Descargas de Visual Studio.

  • Si ya tiene Visual Studio, puede instalar la carga de trabajo desde el entorno de desarrollo interactivo (IDE):

    1. Seleccione Herramientas>Obtener herramientas y características.

    2. En el Instalador de Visual Studio, seleccione la pestaña Cargas de trabajo.

    3. Seleccione la carga de trabajo Desarrollo de escritorio con C++ y, a continuación, seleccione Modificar.

    4. Siga las indicaciones y complete la instalación.

• En este tutorial se usa una aplicación de demostración de C++ y las capturas de pantalla presentan la sintaxis de C++. La mayoría de las características que se muestran también son aplicables a C#, Visual Basic, F#, Python, JavaScript y otros lenguajes compatibles con Visual Studio. Hay algunas limitaciones que debe tener en cuenta:

  • F#: No se admite la característica Editar y continuar.

  • F# y JavaScript: la ventana Motor no se admite.

Creación de un proyecto

Siga estos pasos para crear un proyecto de aplicación de consola de C++ en Visual Studio. El tipo de proyecto proporciona todos los archivos de plantilla que necesita para empezar a trabajar rápidamente:

1. En la ventana Inicio de Visual Studio (Archivo>Ventana Inicio), seleccione Crear proyecto:

   

2. Establezca el filtro de lenguaje en C++ y establezca el filtro de plataforma en Windows .

3. En el cuadro Buscar, escriba consola y seleccione la plantilla Aplicación de consola en la lista de resultados:

   

   Nota

   Si no ve la plantilla Aplicación de consola, puede instalarla desde la ventana Crear un nuevo proyecto. Busque la sección ¿No encuentra lo que busca? que sigue a los resultados de la búsqueda y seleccione Instalar más herramientas y características. En el Instalador Visual Studio, seleccione la carga de trabajo Desarrollo de escritorio con C++ y actualice la instalación. Para obtener más información, consulte la sección Requisitos Previos.

4. Seleccione Siguiente para continuar con la página de configuración.

5. Escriba get-started-debugging como Nombre de proyecto y Nombre de la solución para la nueva aplicación. Elija el valor predeterminado de Ubicación o vaya a otra ruta de acceso de su entorno.

6. Seleccione Crear para crear el nuevo proyecto Node.js.

Visual Studio crea el nuevo proyecto y abre la jerarquía del proyecto en Explorador de soluciones. El archivo get-started-debugging.cpp está abierto en el editor de código.

Creación de la aplicación

Cree una nueva aplicación para el proyecto editando el archivo get-started-debugging.cpp en el editor de código.

Reemplace el contenido predeterminado proporcionado por la plantilla por el código siguiente:

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

Iniciar el depurador

Ahora estás listo para empezar a depurar tu código actualizado:

1. Inicie la sesión de depuración seleccionando F5 o Depurar>. Iniciar Depuración. También puede seleccionar Iniciar depuración (icono de flecha verde sólida) en la barra de herramientas de depuración.

   El método abreviado de teclado F5 inicia la aplicación con el depurador adjunto al proceso de la aplicación, pero aún no tiene nada especial para examinar en el código. La aplicación simplemente se carga y ve la salida de la consola:

   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
   

   Más adelante en el tutorial, verá más detenidamente esta aplicación en el depurador y explorará otras características de depuración.

2. Detenga el depurador seleccionando Detener (un icono de cuadrado rojo) en la barra de herramientas Depuración. También puede usar el atajo de teclado Mayús + F5.

3. En la ventana de consola de la aplicación en ejecución, seleccione cualquier tecla y luego seleccione Enter para cerrar la ventana.

Establecer un punto de interrupción e iniciar el depurador

Intente establecer un punto de interrupción y pausar en el punto seleccionado en el depurador:

1. Vuelva al archivo get-started-debugging.cpp en el editor de código y busque el bucle for de la función main:

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

2. Establezca un punto de interrupción en la línea que contiene la instrucción de código name += letters[i]; seleccionando en el margen izquierdo de dicha línea. Visual Studio agrega un círculo rojo en el margen para indicar el punto de interrupción establecido.

   Sugerencia

   También puede colocar el cursor en una línea de código y seleccionar F9 para alternar el punto de interrupción de esa línea.

   Los puntos de interrupción son una de las características más básicas y esenciales de una depuración confiable. Un punto de interrupción indica dónde desea que Visual Studio suspenda el código en ejecución. Cuando la ejecución está en pausa, puede echar un vistazo a los valores de las variables, examinar el comportamiento de la memoria o comprobar si se ejecuta una rama de código.

3. Inicie la aplicación en el depurador seleccionando F5 o Iniciar depuración.

   Visual Studio inicia la ejecución de la aplicación. Cuando el depurador alcanza el punto de interrupción establecido, el proceso de depuración se pausa.

   Visual Studio agrega una flecha amarilla al círculo rojo del punto de ruptura en el margen para representar la instrucción de código donde está en pausa el depurador. La ejecución del programa está en pausa y la instrucción indicada está esperando que se procese.

   

   Nota

   La acción F5 es relativa al estado de ejecución actual de la aplicación. Si la aplicación no se está ejecutando y selecciona F5, el depurador inicia la aplicación y continúa la ejecución hasta que alcanza el primer punto de interrupción establecido. Este comportamiento corresponde al comando Depurar>Iniciar depuración. Si la aplicación ya se está ejecutando y selecciona F5, la ejecución de la aplicación continúa hasta que el depurador alcanza el siguiente punto de interrupción o el final del programa. Este comportamiento se asigna al comando Depurar>Continuar.

Los puntos de interrupción son una característica útil cuando conoce la línea de código o sección del código que desea examinar con detalle. Para obtener información sobre los distintos tipos de puntos de interrupción que puede establecer, como puntos de interrupción condicionales, vea Use el tipo correcto de punto de interrupción.

Examina el código paso a paso en el depurador

Una manera cómoda de examinar el código en el depurador es usar comandos de paso. Estos comandos le permiten ir paso a paso por las instrucciones, ir paso a paso para salir e ir paso a paso por procedimientos en una sección de código, así como retroceder en la ejecución de la aplicación.

En el procedimiento siguiente se resalta cómo usar atajos de teclado con comandos de paso para navegar rápidamente por el código. (Las acciones de menú equivalentes se muestran entre paréntesis).

1. Inicie la aplicación en el depurador seleccionando F5 o Iniciar depuración.

2. Mientras el depurador está en pausa en el bucle for de la función main, seleccione F11 (Depurar > Paso a paso por instrucciones) dos veces para avanzar SendMessage a la llamada de método.

   Después de seleccionar F11 dos veces, la ejecución continúa con la instrucción de código SendMessage(name, a[i]);.

3. Seleccione F11 de nuevo para entrar en el método SendMessage.

   Observe que el puntero amarillo avanza en el método SendMessage:

   

   El método abreviado de teclado F11 inicia el comando Paso a paso por instrucciones, lo que hace avanzar la ejecución de la aplicación una instrucción cada vez. Es una buena manera de examinar el flujo de ejecución con más detalle. De forma predeterminada, el depurador omite el código que no es de usuario. Para obtener más información, consulte Just My Code. Más adelante en el tutorial, aprenderá a avanzar más rápido a través de su código.

4. Después de examinar el método SendMessage, puede continuar con la depuración con el comando Paso a paso para salir. Seleccione Mayús + F11 (Depurar > Paso a paso para salir).

   Este comando reanuda la ejecución de la aplicación (y avanza el depurador) hasta que se devuelva el método o función actual.

   Cuando se completa el comando, el depurador se detiene en el bucle for del método main en la llamada al método SendMessage.

5. Seleccione varias veces F11 hasta que vuelva de nuevo a la llamada al método SendMessage.

6. Mientras el depurador está en pausa en la llamada al método, seleccione F10 (Depurar > Paso a paso por procedimientos).

   

   En este caso, tenga en cuenta que el depurador no depura paso a paso por instrucciones el método SendMessage. El método abreviado de teclado F10 avanza el depurador sin ir paso a paso por instrucciones en funciones o métodos en el código de la aplicación (el código se sigue ejecutando). Al seleccionar F10 en la llamada al método SendMessage (en lugar de F11), irá paso a paso por procedimientos en el código de implementación de SendMessage. Este enfoque es útil para pasar por alto código que no necesitas inspeccionar en este momento. Para más información sobre las distintas formas de desplazarse por el código, vea Navegación por el código en el depurador.

Examinar tu código con Ejecutar hasta clic

Otra forma de navegar por tu código en el depurador es utilizando la funcionalidad Run to Click. Esta acción es similar a establecer un punto de interrupción temporal.

Continúe con la sesión de depuración:

1. Seleccione F5 para avanzar al punto de interrupción en el código.

2. En el editor de código, desplácese hasta la definición del método SendMessage y mantenga el puntero sobre la función std::wcout.

   Mantenga el puntero hasta que aparezca Ejecutar hasta hacer clic (icono de flecha verde) a la izquierda de la instrucción de código. Si mantiene el puntero sobre el icono, verá el mensaje emergente "Ejecutar ejecución hasta aquí".

   

3. Seleccione Ejecutar hasta clic.

   El depurador avanza la ejecución a la posición indicada. En este ejemplo, el depurador alcanza la llamada a la función std::wcout.

La acción Ejecutar hasta clic es útil para moverse rápidamente dentro de una región visible del código de la aplicación. Puede usar la característica en cualquier archivo abierto en el editor de código.

Reinicio rápido de la aplicación

Reinicia rápidamente tu aplicación seleccionando Reiniciar (icono de flecha circular) en la barra de herramientas de depuración. También puede seleccionar Depurar > Reiniciar o usar el método abreviado de teclado Ctrl + Mayús + F5.

La función Reiniciar es más eficaz que detener la aplicación e iniciar de nuevo el depurador.

Al seleccionar Reiniciar, el depurador pausa en el primer punto de interrupción que encuentra durante la ejecución. En este ejemplo, el depurador se detiene de nuevo en el punto de interrupción que estableciste dentro del bucle for.

Inspeccionar variables con información sobre datos

Las características que le ayudan a inspeccionar variables son una de las ventajas más útiles de trabajar con el depurador. A menudo, al depurar un problema, intenta detectar si las variables almacenan valores esperados en momentos concretos. Visual Studio proporciona varias maneras de ayudarle a completar esta tarea.

Continúe con la sesión de depuración:

1. Mientras el depurador está en pausa en la instrucción name += letters[i], pase el ratón sobre la variable letters. Seleccione la flecha expandir o contraer a la izquierda del nombre de la variable y vea sus propiedades en el menú flotante.

   La característica de sugerencias de datos muestra todos los elementos que la variable contiene. Observe el valor predeterminado, size={10}:

   

2. A continuación, mantenga el puntero sobre la variable name y observe su valor actual, una cadena vacía ("").

3. Seleccione F5 (Depurar>Continuar) varias veces para iterar varias veces a través del bucle for. Cada vez que el depurador se pausa en el punto de interrupción, mantenga el puntero sobre la variable name y compruebe el valor actual:

   

   El valor de la variable cambia con cada iteración del bucle for, mostrando los valores de f, luego fr, luego fre, etc.

Inspección de variables con las ventanas Automático y Variables locales

Otro enfoque para inspeccionar variables y valores es usar las ventanas Motor y Variables locales. De forma predeterminada, estas ventanas aparecen debajo del editor de código en el IDE de Visual Studio mientras depura tu aplicación.

1. Observe la ventana de Automático debajo del editor de código.

   Si no ve la ventana durante la sesión de depuración, seleccione Depurar>Windows>Motor para abrir la ventana.

   La ventana Autos muestra todas las variables usadas en la línea actual o en la línea anterior junto con su valor actual. Tenga en cuenta que los lenguajes de programación específicos pueden demostrar un comportamiento único para las variables y las propiedades. Para obtener más información, consulte la guía del lenguaje de Visual Studio .

2. A continuación, eche un vistazo a la ventana Variables locales. De forma predeterminada, esta ventana se alinea junto a la ventana Autos.

   Si no ve la ventana durante la sesión de depuración, seleccione Depurar>Windows>Variables locales para abrir la ventana.

3. En la ventana Variables locales, expanda la variable letters para mostrar los elementos que contiene.

   

   La ventana Locales muestra las variables que se encuentran en el ámbito actual , es decir, el contexto de ejecución actual.

Supervisar una variable

Si le interesa observar el comportamiento de una variable específica, puede establecer una inspección:

En el editor de código, haga clic con el botón derecho en la variable name y seleccione Agregar observación. La ventana Inspección se abre debajo del editor de código. Puede usar una ventana Inspección para especificar una variable (o una expresión) a la que quiera realizar un seguimiento.

Mientras observa la variable name durante la ejecución de la aplicación en el depurador, puede ver cómo cambia su valor. A diferencia de las otras ventanas de variables, en la ventana Inspección siempre se muestran las variables que está viendo. Cuando una variable observada no está en el ámbito, el nombre de la variable se atenúa.

Examinar la pila de llamadas

La ventana Pila de llamadas en Visual Studio muestra el orden en el que se llama a los métodos y funciones. Esta ventana es similar a la perspectiva de depuración en algunos entornos de desarrollo integrado, como Eclipse. De forma predeterminada, la pila de llamadas se muestra en el panel inferior derecho durante la sesión de depuración, por debajo del editor de código.

1. Mientras el depurador está en pausa en el bucle for, seleccione la ventana Pila de llamadas para ver la estructura de llamada actual.

   Si no ve la ventana durante la sesión de depuración, seleccione Depurar>Windows>Pila de llamadas para abrirla.

2. Seleccione F11 (Depurar>Paso a paso por instrucciones) varias veces hasta que vea que el depurador se detiene en el método SendMessage.

3. Eche un vistazo a la ventana Pila de llamadas de nuevo.

   

   En la ventana de pila de llamadas , la línea superior muestra la función actual (el método SendMessage en esta aplicación). La segunda línea muestra que se llamó al método SendMessage desde el método main, etc.

La pila de llamadas es una buena manera de examinar y comprender el flujo de ejecución de una aplicación:

• Haga doble clic en una línea de código para ir al código fuente. Esta acción también cambia el ámbito actual bajo inspección por parte del depurador, pero no hace avanzar al depurador.

• Acceda a los menús contextuales de los elementos de programación en la ventana Pila de llamadas. Por ejemplo, puede insertar puntos de interrupción en funciones especificadas, avanzar el depurador mediante Ejecutar hasta el cursor y examinar el código fuente. Para obtener más información, consulte Visualización de la pila de llamadas y uso de la ventana Pila de llamadas en el depurador.

Cambio del flujo de ejecución

Otra característica del depurador en Visual Studio es la capacidad de cambiar el flujo de ejecución de la aplicación:

1. Seleccione F11 (Depurar>Paso a paso por instrucciones) dos veces para ejecutar la función std::wcout.

2. Mientras el depurador está en pausa en la llamada al método SendMessage, seleccione y arrastre la flecha amarilla (el puntero de ejecución) a la izquierda de la variable y mueva la flecha a la instrucción de código anterior, std::wcout.

3. Seleccione F11 de nuevo.

   El depurador vuelve a ejecutar la función std::wcout. Puede realizar un seguimiento del proceso en la salida del terminal.

   Al cambiar el flujo de ejecución, puede hacer cosas como probar diferentes rutas de ejecución de código o volver a ejecutar código sin reiniciar el depurador.

   Cautela

   Preste atención al trabajar con esta característica. Al seleccionar la flecha amarilla, Visual Studio muestra una advertencia en la información sobre herramientas que indica que el cambio de ejecución puede tener consecuencias imprevistas. También puede ver otras advertencias, en función de su escenario. Tenga en cuenta que mover el puntero no puede revertir la aplicación a un estado de aplicación anterior.

4. Seleccione F5 para completar la ejecución de la aplicación.

Contenido relacionado

• Primer vistazo al depurador de Visual Studio
• Navegar por el código mediante el depurador de Visual Studio
• Usar el tipo correcto de punto de interrupción (.NET, .NET Framework, C++, Todos los lenguajes)