3.7 – Использование встроенного отладчика: запуск и точки останова
Пошаговое выполнение (рассматривается в уроке «3.6 – Использование встроенного отладчика: пошаговое выполнение») полезно для изучения каждой отдельной строки вашего кода изолированно. Но в большой программе может потребоваться много времени, чтобы пройти через весь код, чтобы даже добраться до точки, которую вы хотите изучить более подробно.
К счастью, современные отладчики предоставляют больше инструментов, которые помогают нам эффективно отлаживать наши программы. В этом уроке мы рассмотрим некоторые функции отладчика, которые позволяют нам быстрее ориентироваться в коде.
Выполнение до курсора
Первую полезную команду обычно называют «Выполнить до курсора» (Run to Cursor). Эта команда «Выполнить до курсора» выполняет программу до тех пор, пока выполнение не достигнет инструкции, выбранной курсором. Затем отладчик возвращает управление вам, чтобы вы могли начать отладку с этой точки. Это обеспечивает эффективный способ начать отладку в определенной точке вашего кода или, если уже отладка начата, перейти прямо в то место, которое вы хотите изучить дальше.
Для пользователей Visual Studio
В Visual Studio к команде выполнения до курсора можно получить доступ, кликнув правой кнопкой мыши на инструкции в коде и выбрав в контекстном меню Выполнить до текущей позиции (Run to Cursor), или нажав комбинацию клавиш Ctrl + F10 .
Для пользователей Code::Blocks
В Code::Blocks к команде «выполнить до курсора» можно получить доступ, кликнув правой кнопкой мыши на инструкции в коде и выбрав либо Run to Cursor (Выполнить до курсора) из контекстного меню, либо меню Debug (Отладка) → Run to Cursor (Выполнить до курсора), либо нажав клавишу F4 .
Давайте попробуем эту команду с помощью той же программы, которую мы использовали в предыдущем уроке:
Просто кликните правой кнопкой мыши в любом месте строки 5, затем выберите Выполнить до текущей позиции.
Рисунок 1 – Положение маркера выполнения после запуска выполнения до курсора для строки 5
Вы заметите, что программа запустится, а маркер выполнения переместится на только что выбранную строку. Ваша программа выполнилась до этой точки и теперь ожидает ваших дальнейших команд отладки. Отсюда вы можете пошагово выполнять свою программу, переходить к курсору в другое место и т.д.
Если вы запустили выполнение до курсора для места, которое не выполняется, выполнение до курсора просто запустит вашу программу до ее завершения.
Продолжение
Когда вы находитесь в середине сеанса отладки, вы можете захотеть просто запустить выполнение программы с этой точки. Самый простой способ сделать это – использовать команду Продолжить (Continue). Команда отладки Продолжить (Continue) просто продолжает выполнение программы как обычно, либо до тех пор, пока программа не завершится, либо пока что-то не вызовет возврат управления вам (например, точка останова, которую мы рассмотрим позже в этом уроке).
Для пользователей Visual Studio
В Visual Studio к команде продолжить можно получить доступ во время отладки программы через меню Отладка (Debug) → Продолжить (Continue), или нажав клавишу F5 .
Для пользователей Code::Blocks
В Code::Blocks к команде продолжить можно получить доступ во время отладки программы через меню Debug (Отладка) → Start / Continue (Запуск / Продолжить), или нажав клавишу F8 .
Давайте протестируем команду продолжить. Если маркер выполнения еще не находится в строке 5, запустите выполнение до курсора для строки 5. Затем выберите продолжить с этой точки. Ваша программа завершит выполнение, а затем завершится.
Запуск
У команды продолжить есть брат-близнец по имени запуск. Команда Запуск (Start) выполняет то же действие, что и продолжить, только начиная с самого начала программы. Её можно вызвать только тогда, когда сеанс отладки еще не запущен.
Для пользователей Visual Studio
В Visual Studio к команде запуска можно получить доступ, когда отладка программы еще не выполняется, с помощью меню Отладка (Debug) → Начать отладку (Start Debugging) или путем нажатия клавиши F5 .
Для пользователей Code::Blocks
В Code::Blocks к команде запуска можно получить доступ, когда отладка программы еще не выполняется, с помощью меню Debug (Отладка) → Start / Continue (Запуск / Продолжить), или нажав клавишу F8 .
Если вы используете команду запуска в приведенном выше примере программы, она будет выполняться без прерываний. Хотя это может показаться бесполезным, но это только потому, что мы не сказали отладчику прервать выполнение программы. Мы воспользуемся этой командой с большей пользой в следующем разделе.
Точки останова
Последняя тема, о которой мы поговорим в этом разделе, – это точки останова. Точка останова (breakpoint) – это специальный маркер, который сообщает отладчику остановить выполнение программы при работе в режиме отладки в точке останова.
Для пользователей Visual Studio
В Visual Studio вы можете установить или удалить точку останова через меню Отладка (Debug) → Вставить точку останова (Insert breakpoint) / Удалить точку останова (Delete breakpoint), или кликнув правой кнопкой мыши на инструкции и выбрав в контекстном меню Вставить точку останова (Insert breakpoint) / Удалить точку останова (Delete breakpoint), либо нажав клавишу F9 , либо кликнув слева от номера строки (в светло-серой области).
Для пользователей Code::Blocks
В Code::Blocks вы можете установить или удалить точку останова через меню Debug (Отладка) → Toggle breakpoint (Переключить точку останова), или кликнув правой кнопкой мыши на инструкции и выбрав в контекстном меню Toggle breakpoint (Переключить точку останова), либо нажав клавишу F5 , либо кликнув справа от номера строки.
Когда вы установите точку останова, вы увидите значок нового типа. Visual Studio и Code::Blocks используют красный кружок:
Рисунок 2 – Индикация точки останова в строке 5
Установите точку останова в строке 5, как показано на изображении выше.
Теперь выберите команду запуск, чтобы отладчик запустил ваш код, и давайте посмотрим, как работает точка останова. Вы заметите, что вместо того, чтобы работать до конца программы, отладчик останавливается в точке останова (с маркером выполнения, расположенным над значком точки останова):
Рисунок 3 – Отладчик остановился в точке останова в строке 5
Это как если бы вы запустили выполнение до курсора в этой точке.
Точки останова имеют несколько преимуществ по сравнению с выполнением до курсора. Во-первых, точки останова заставят отладчик возвращать вам управление каждый раз, когда они встречаются (в отличие от выполнения до курсора, которое выполняется до курсора только один раз при каждом вызове). Во-вторых, вы можете установить точку останова, и она будет сохраняться до тех пор, пока вы ее не удалите, тогда как с выполнением до курсора вам нужно находить место, до которого вы хотите запустить выполнение, каждый раз, когда вы вызываете команду.
Обратите внимание, что точки останова, размещенные на строках, которые не находятся на пути выполнения, не заставят отладчик останавливать выполнение кода.
Давайте взглянем на слегка измененную программу, которая лучше иллюстрирует разницу между точками останова и выполнением до курсора:
Сначала запустите новый сеанс отладки, а затем выполнение до курсора в строке 5. Теперь выберите продолжить. Программа продолжится до конца (она не остановится на строке 5 снова, даже если строка 5 выполняется еще дважды).
Затем установите точку останова в строке 5, затем выберите запуск. Программа остановится на строке 5. Теперь выберите продолжить. Программа остановится на строке 5 во второй раз. Выберите продолжить снова, и она остановится в третий раз. Еще одна команда продолжить, и программа завершится. Вы можете видеть, что точка останова заставляла программу останавливаться столько раз, сколько выполнялась эта строка.
Задать следующую инструкцию
Есть еще одна команда отладки, которая используется довольно редко, но, по крайней мере, о ней стоит знать, даже если вы не будете использовать ее очень часто. Команда Задать следующую инструкцию (Set next statement) позволяет нам изменить точку выполнения на какую-либо другую инструкцию (иногда неофициально называется прыжком). Её можно использовать для прыжка вперед к точке выполнения и пропуска кода, который в противном случае выполнялся бы, или назад для того, чтобы что-то, что уже было выполнено, запустилось снова.
Для пользователей Visual Studio
В Visual Studio вы можете перейти к точке выполнения, кликнув на инструкции правой кнопкой мыши и выбрав Задать следующую инструкцию (Set next statement) в контекстном меню, или нажав комбинацию клавиш Ctrl + Shift + F10 . Этот пункт является контекстным и появляется только при отладке программы.
Для пользователей Code::Blocks
В Code::Blocks вы можете перейти к точке выполнения через меню Debug (Отладка) → Set next statement (Задать следующую инструкцию), или кликнув правой кнопкой мыши на инструкции и выбрав Set next statement (Задать следующую инструкцию) в контекстном меню. Code::Blocks не имеет сочетания горячих клавиш для этой команды.
Давайте посмотрим, как прыгать вперед:
Сначала запустите выполнение до курсора в строке 11. На этом этапе вы должны увидеть значение 5 в окне консоли.
Теперь кликните правой кнопкой мыши на строку 12 и выберите Задать следующую инструкцию. Это приведет к тому, что строка 11 пропускается и не выполняется. Затем выберите Продолжить, чтобы завершить выполнение программы.
Результат работы вашей программы должен выглядеть так:
Мы видим, что вызов printValue(6) был пропущен.
Эта функция может быть полезна в нескольких контекстах.
В нашем исследовании основных методов отладки мы обсудили закомментирование функции как способ определить, сыграла ли данная функция роль в возникновении проблемы. Для этого необходимо изменить наш код и позже не забыть раскомментировать функцию. В отладчике нет прямого способа пропустить функцию, поэтому, если вы решите, что хотите это сделать, использование Задать следующую инструкцию (Set next statement) для прыжка через вызов функции – самый простой способ сделать это.
Прыжок назад также может быть полезен, если мы хотим увидеть, как только что выполненная функция запускается снова, чтобы мы могли увидеть, что она делает.
С тем же кодом, приведенным выше, запустите выполнение до курсора в строке 12. Затем задайте следующую инструкцию на строку 11 и выполните команду продолжить. Результат работы программы должен быть следующим:
Предупреждение
Команда задать следующую инструкцию изменит точку выполнения, но не изменит состояние программы. Ваши переменные сохранят те значения, которые были у них до прыжка. В результате прыжки могут привести к тому, что ваша программа будет выдавать значения, результаты или поведение, отличающиеся от обычного последовательного выполнения. Используйте эту функцию с умом (особенно при прыжках назад).
Предупреждение
Вы не должны использовать команду задать следующую инструкцию для изменения точки выполнения на другую функцию. Это приведет к неопределенному поведению и, вероятно, к сбою.
Заключение
Теперь вы узнали об основных способах использования встроенного отладчика для наблюдения и управления выполнением вашей программы. Хотя эти команды могут быть полезны для диагностики проблем с последовательностью выполнения кода (например, для определения того, вызываются ли определенные функции или нет), они являются лишь частью преимуществ, которые дает встроенный отладчик. В следующем уроке мы начнем изучать дополнительные способы проверки состояния вашей программы, для чего вам понадобится использование этих команд.
Урок №26. Отладка программ: степпинг и точки останова
Как ни странно, программирование может быть сложным и ошибок может быть очень много. Ошибки, как правило, попадают в одну из двух категорий: синтаксические или семантические/смысловые.
Типы ошибок
Синтаксическая ошибка возникает, когда вы пишете код, который не соответствует правилам грамматики языка C++. Например, пропущенные точки с запятой, необъявленные переменные, непарные круглые или фигурные скобки и т.д. В следующей программе есть несколько синтаксических ошибок:
К счастью, компилятор ловит подобные ошибки и сообщает о них в виде предупреждений или ошибок.
Семантическая ошибка возникает, когда код является синтаксически правильным, но делает не то, что задумал программист.
Иногда это может привести к сбою в программе, например, если делить на ноль:
Либо делать вообще не то, что нужно:
К сожалению, компилятор не ловит подобные ошибки, так как он проверяет только то, что вы написали, а не то, что вы хотели этим сделать.
В примерах, приведенных выше, ошибки довольно легко обнаружить. Но в большинстве программ (в которых больше 40 строк кода), семантические ошибки увидеть с помощью простого просмотра кода будет не так-то и легко.
И здесь нам на помощь приходит отладчик.
Отладчик
Отладчик (или «дебаггер», от англ. «debugger») — это компьютерная программа, которая позволяет программисту контролировать выполнение кода. Например, программист может использовать отладчик для выполнения программы пошагово, последовательно изучая значения переменных в программе.
Старые дебаггеры, такие как GDB, имели интерфейс командной строки, где программисту приходилось вводить специальные команды для старта работы. Современные дебаггеры имеют графический интерфейс, что значительно упрощает работу с ними. Сейчас почти все современные IDE имеют встроенные отладчики. То есть, вы можете использовать одну среду разработки как для написания кода, так и для его отладки (вместо постоянного переключения между разными программами).
Базовый функционал у всех отладчиков один и тот же. Отличаются они, как правило, тем, как этот функционал и доступ к нему организованы, горячими клавишами и дополнительными возможностями.
Примечание: Перед тем как продолжить, убедитесь, что вы находитесь в режиме конфигурации «Debug». Все скриншоты данного урока выполнены в Visual Studio 2019.
Степпинг
Степпинг (англ. «stepping») — это возможность отладчика выполнять код пошагово (строка за строкой). Есть три команды степпинга:
Команда «Шаг с заходом»
Команда «Шаг с обходом»
Команда «Шаг с выходом»
Мы сейчас рассмотрим каждую из этих команд в индивидуальном порядке.
Команда «Шаг с заходом»
Команда «Шаг с заходом» (англ. «Step into») выполняет следующую строку кода. Если этой строкой является вызов функции, то «Шаг с заходом» открывает функцию и выполнение переносится в начало этой функции.
Давайте рассмотрим очень простую программу:
Как вы уже знаете, при запуске программы выполнение начинается с вызова главной функции main(). Так как мы хотим выполнить отладку внутри функции main(), то давайте начнем с использования команды «Шаг с заходом».
В Visual Studio, перейдите в меню «Отладка» > «Шаг с заходом» (либо нажмите F11 ):
Если вы используете другую IDE, то найдите в меню команду «Step Into/Шаг с заходом» и выберите её.
Когда вы это сделаете, должны произойти две вещи. Во-первых, так как наше приложение является консольной программой, то должно открыться консольное окно. Оно будет пустым, так как мы еще ничего не выводили. Во-вторых, вы должны увидеть специальный маркер слева возле открывающей скобки функции main(). В Visual Studio этим маркером является жёлтая стрелочка (если вы используете другую IDE, то должно появиться что-нибудь похожее):
Стрелка-маркер указывает на следующую строку, которая будет выполняться. В этом случае отладчик говорит нам, что следующей строкой, которая будет выполняться, — будет открывающая фигурная скобка функции main(). Выберите «Шаг с заходом» еще раз — стрелка переместится на следующую строку:
Это значит, что следующей строкой, которая будет выполняться, — будет вызов функции printValue(). Выберите «Шаг с заходом» еще раз. Поскольку printValue() — это вызов функции, то мы переместимся в начало функции printValue():
Выберите еще раз «Шаг с заходом» для выполнения открывающей фигурной скобки printValue(). Стрелка будет указывать на std::cout << nValue; .
Теперь выберите «Шаг с обходом» (F10). Вы увидите число 5 в консольном окне.
Выберите «Шаг с заходом» еще раз для выполнения закрывающей фигурной скобки printValue(). Функция printValue() завершит свое выполнение и стрелка переместиться в функцию main(). Обратите внимание, в main() стрелка снова будет указывать на вызов printValue():
Может показаться, будто отладчик намеревается еще раз повторить цикл с функцией printValue(), но в действительности он нам просто сообщает, что он только что вернулся из этой функции.
Выберите «Шаг с заходом» два раза. Готово, все строки кода выполнены. Некоторые дебаггеры автоматически прекращают сеанс отладки в этой точке. Но Visual Studio так не делает, так что если вы используете Visual Studio, то выберите «Отладка» > «Остановить отладку» (или Shift+F5 ):
Таким образом мы полностью остановили сеанс отладки нашей программы.
Команда «Шаг с обходом»
Как и команда «Шаг с заходом», команда «Шаг с обходом» (англ. «Step over») позволяет выполнить следующую строку кода. Только если этой строкой является вызов функции, то «Шаг с обходом» выполнит весь код функции в одно нажатие и возвратит нам контроль после того, как функция будет выполнена.
Примечание для пользователей Code::Blocks: Команда «Step over» называется «Next Line».
Точки останова с условием в Visual Studio. Основы
Visual Studio позволяет устанавливать условия при выполнении которых выполнение программы будет приостановлено и вы перейдёте в отладчик в данной точке останова.
В качестве примера рассмотрим простейшую программу, которая выводит числа от 0 до 10.
Точку останова мы поставим внутри цикла на операторе, который выводит на экран консоли значение переменной i.
Если мы просто поставим точку останова (см. скриншот ниже), то выполнение программы будет приостанавливаться на каждой итерации цикла.
Но, в этом не всегда есть необходимость. Также при большом количестве итераций это как правило увеличивает время отладки потому, что:
- Нужная итерация может выполняться не вначале алгоритма и до неё цикл должен выполниться определённое количество раз;
- Даже после выполнения нужной итерации точка останова без условия будет приводить к приостановке программы при каждом выполнении цикла до тех пор, пока программа из него не выйдет.
Помимо вышесказанного обычная точка останова может создать немало трудностей и при отладке алгоритмов, не содержащих циклы или ошибок с ними не связанных (во всяком случае напрямую). Например, если ошибка в методе класса воспроизводится только при определённых исходных данных нет смысла переходить в отладчик при каждом его вызове.
Но, как сделать чтобы точка останова срабатывала только при определённых условиях?
Для этого в интерфейсе Visual Studio нужно навести курсор мыши на точку останова. В появившейся рядом панели нажать кнопку со значком в виде шестерни. В открывшемся окне установить флажок «Условие». После этого в правом текстовом поле можно указать условия срабатывания точки останова.
Как это выглядит показано ниже на скриншоте.
Условия для точек останова записываются в виде логического выражения на языке программирования проекта. То есть, если ваш проект на C# (как в нашем примере) условие следует записать на C#. Если на VB.NET, то на VB.NET и т.д.
После нажатия кнопки «Закрыть» параметры точки останова (включая условие) будут сохранены. Для наглядности значок точки останова, для которой заданы специальные параметры, изменит свой вид (см. скриншот).
В данном примере точка останова будет срабатывать при значении переменной I равном 5.
Как это выглядит в отладчике:
Как это выглядит в программе:
Важно отметить, что в данной статье мы разобрали лишь простейший пример.
Условия для точек останова могут быть гораздо сложнее. Также возможности отладчика Visual Studio не ограничиваются только проверкой логических выражений.
На скриншоте ниже показан пример точки останова, которая срабатывает при изменении значения переменной (в данном случае i).
Характер условия точки останова задаётся в среднем поле (см. скриншот) в выпадающем меню. Также это меню определяет какие условия могут быть доступны дополнительно. Но, это уже тема для отдельной статьи.
Отладка в visual studio. Поиск логических ошибок в программе
Как было показано в предыдущем разделе на примере программы, преобразующей массив целых чисел, приложение может собираться и работать, но не выполнять полностью того, что ему полагается делать. Это означает, что текст программы не соответствует спецификации поставленной задачи и содержит логическую ошибку, а возможно, сразу и несколько логических ошибок.
Из всех категорий ошибок логические ошибки найти наиболее трудно, так как они берут свое начало в ошибочном рассуждении при поиске решения задачи. Такие ошибки обнаруживаются на этапе выполнения программы и приводят к неверным результатам, к остановке или «зависанию» приложения. Это делает необходимым тестирование приложения с различными наборами данных. Только тщательное тестирование на самых разнообразных значениях данных может дать на практике гарантию того, что приложение не содержит логических ошибок.
Самым простым способом локализации логической ошибки является пошаговое прослеживание результатов выполнения всех операторов программы. При отладке приложения в VS можно отображать значения указанных переменных или выражений в любой точке программы.
Вычисленные значения можно, сравнивать с теми, что должны быть, и если обнаруживается несоответствие, то, логическая ошибка локализована.
Начало сеанса отладки
Первый шаг отладки приложения – это выбор команды Start Debugging (F5) на стандартной панели инструментов или в меню Debug, после чего приложение запускается в режиме отладки.
Перед началом отладки целесообразно определить то место в программе, где возможна ошибка. Это, как правило, позволяет существенно сократить время, затрачиваемое на поиски ошибки. В примере 2 ошибка может содержаться в том фрагменте программы, который изменяет значения элементов массива после их ввода с клавиатуры.
Установка точек останова
Для того чтобы отладчик прерывал выполнение программы на определенной строке, необходимо установить на этой строке точку останова. Точка останова – это просто место (например, строка с оператором программы), которое помечено для отладчика и отображается красным кружком в поле индикаторов (узкое поле серого цвета с левого края окна редактора кода). Когда отладчик встречает точку останова, то выполняющаяся программа моментально останавливается (до выполнения данной строки кода).
Установить точку останова на какой-либо строке кода можно при помощи щелчка по полю индикаторов данной строки (рис. 16). Либо можно установить курсор на нужной строке и нажать клавишу F9.
Рисунок 16. Установка точки останова
Просмотр данных в отладчике
Когда выполнение программы в сеансе отладки приостановлено (например, при помощи точки останова), можно изучить состояние и содержимое ее переменных и объектов. Для этого в VS можно использовать три вида окон: Local (Локальные), Autos (Видимые) и Watch (Контрольные).
Доступ к окнам можно получить нажав Debug->Windows->выбрать нужное окно(Рис. 17)
Рисунок 17. Доступ к окнам
Окно Local показывает все переменные и их значения для текущей области видимости отладчика. Это дает вам представление обо всем, что имеется в текущей выполняющейся функции. Переменные в этом окне организованы в список и автоматически настраиваются отладчиком. На рис. 18 показан пример окна Local. С его помощью можно увидеть приложение нашего примера, которое приостановлено до обнуления соответствующих элементов массива. Обратите внимание, что объект (массив) a развернут для того, чтобы показать значения его элементов в момент остановки выполнения программы. По мере установки значений результаты будут отображаться в столбце Value.
Однако очень часто просмотр всех локальных переменных дает слишком много информации, чтобы в ней можно было разобраться. Так может происходить тогда, когда в области видимости данного процесса или функции находится слишком много операторов. Для того
чтобы увидеть значения, связанные с той строкой кода, на которую вы смотрите, можно использовать окно Autos. Это окно показывает значения всех переменных и выражений, имеющихся в текущей выполняющейся строке кода или в предыдущей строке кода. На рис. 19
показано окно Autos для той же самой строки кода, которая показана на рис. 18. Обратите внимание на разницу.
Окна Watch в VS позволяют настраивать собственный список переменных и выражений, за которыми нужно наблюдать (рис. 20). Окна Watch выглядят и ведут себя точно так же, как и окна Local и Autos. Кроме того, те элементы, которые вы размещаете в окнах Watch, сохраняются между сеансами отладки.
Рисунок 18. Окно Local
Рисунок 19. Окно Autos
Вы получаете доступ к окнам Watch из меню или панели инструментов Debug (рис. 17). Четыре окна Watch (которые называются Watch 1, Watch 2, Watch 3 и Watch 4) позволяют настроить четыре списка элементов, за которыми необходимо наблюдать. Эта возможность может быть особенно полезна в том случае, когда каждый список относится к отдельной области видимости вашего приложения.
Переменную или выражение в окно Watch 1 можно добавить из редактора кода. Для этого в редакторе кода выделите переменную (или выражение), щелкните по ней правой кнопкой мыши и выберите пункт Add Watch. При этом выделенная переменная (или выражение) будет помещена в окно Watch 1. Вы можете также перетащить выделенный элемент в это окно.
Рисунок 20. Окно Watch 1
Пошаговое прохождение для поиска ошибки
После того как в нашем примере отладчик, встретив точку останова, прервал выполнение программы, далее можно выполнять код по шагам (режим трассировки). Для этого можно выбрать команду Step into на панели инструментов Debug или нажать функциональную клавишу F11(Рис. 21). Это приведет к последовательному выполнению кода по одной строке, что позволит вам видеть одновременно и ход выполнения приложения, и состояние объектов программы по мере выполнения кода. Команда Step into (F11) позволяет продвигаться по коду по одной строке. Вызов этой команды выполнит текущую строку кода и поместит курсор на следующую выполняемую строку. Важное различие между Step into и другими похожими командами состоит в
том, как Step into обрабатывает строки кода, в которых содержатся вызовы функций. Если вы находитесь на строке кода, которая вызывает другую функцию программы, то выполнение команды Step into перенесет вас на первую строку этой функции.
Если сделать так в нашем примере, то вы увидите ошибку: обнуление элементов массива должно начинаться не с элемента с индексом i1, а со следующего элемента i1+1.
Команда Step out (F10) позволяет вам сохранять фокус в текущей функции (не заходя в вызываемые ею подпрограммы), т. е. вызов Run out приведет к выполнению строки за строкой, но не заведет вас в вызовы функций и при этом следующей выполняемой
строкой для пошагового прохождения станет следующая за вызовом функции строка.
Рис 21. Команда Step Into
Одной из более удобных (и часто упускаемых) функциональных возможностей набора инструментов отладки является функция Run to cursor ( Выполнить до текущей позиции). Она работает в полном соответствии со своим названием. Вы устанавливаете курсор на некий код и вызываете эту команду. Приложение компилируется и выполняется до тех пор, пока не доходит до той строки, где находится курсор. В этой точке отладчик прерывает приложение и выдает вам эту строку кода для пошагового прохождения. Рис. 22.
Рисунок 22. Вызов команды Run To Cursor
Продолжить отладку после точки останова можно повторным нажатием на кнопку F5 (Start Debugging).
Рисунок 23. Результат работы программы после исправления ошибки
Рассмотрим пошаговое выполнение программы с использованием окна Watch на простейшем примере.