Как закрыть приложение c
В последнее время я пытаюсь изучить С++ из этого веб-сайта. К сожалению, всякий раз, когда я пытаюсь запустить один из примеров кода, я вижу, что эта программа открыта примерно на полсекунды, а затем сразу же закрывается. Есть ли способ немедленно закрыть программу, чтобы я мог видеть плоды моих усилий?
ОТВЕТЫ
Ответ 1
Изменить: Как справедливо отмечает Чарльз Бейли в комментарии ниже, это не сработает, если в stdin есть символы, буферизированные, и на самом деле нет хорошего способа обойти это. Если вы используете прилагаемый отладчик, предлагаемое решение John Dibling, вероятно, является самым чистым решением вашей проблемы.
Тем не менее, я оставлю это здесь, и, возможно, кто-то найдет это полезным. Я часто использовал его в качестве быстрого взлома при написании тестов во время разработки.
В конце вашей функции main вы можете вызвать std::getchar();
Ответ 2
Если вы используете Visual Studio, и вы запускаете консольное приложение из среды IDE:
нажатие CTRL-F5 (запуск без отладки) запустит приложение и откроет окно консоли, пока вы не нажмете любую клавишу.
Ответ 3
Решение James работает для всех платформ.
В качестве альтернативы на Windows вы также можете добавить следующее перед возвратом из функции main :
Ответ 4
Если вы используете Microsoft Visual С++ 2010 Express и столкнулись с проблемой: CTRL + F5 не работает для того, чтобы консоль открылась после завершения программы, посмотрите этот поток MSDN.
Вероятно, ваша IDE настроена на закрытие консоли после запуска CTRL + F5; на самом деле, "пустой проект" в Visual С++ 2010 закрывает консоль по умолчанию. Чтобы изменить это, сделайте так, как предположил Microsoft-модератор:
Ответ 5
Обычно я просто устанавливаю точку останова на main() , закрывая фигурные скобки. Когда конец программы будет достигнут любым способом, на который ударит точка останова, и вы можете ALT-Tab в окне консоли, чтобы просмотреть результат.
Ответ 6
Почему бы не просто запустить программу с консоли, а запустить программу из cmd.exe, если вы используете Windows. Таким образом, окно остается открытым после завершения программы.
[EDIT]: Когда я использую KDevelop4, на вкладке внизу среды IDE имеется полностью установленный экземпляр Bash (CLI Linux). Это то, что я использую в таких обстоятельствах.
Ответ 7
До конца кода вставьте эту строку:
Это будет держать консоль до тех пор, пока вы не нажмете клавишу.
Ответ 8
Вызвать cin.get(); 2 раза:
Ответ 9
Если вы запустите свой код из компетентной среды разработки, например Code:: Blocks, среда IDE будет управлять консолью, которую она использует для запуска код, сохраняя его открытым, когда приложение закрывается. Вы не хотите добавлять специальный код, чтобы консоль открывалась, потому что это предотвратит его правильное функционирование, если вы используете его на самом деле, вне среды IDE.
Ответ 10
Если вы действительно отлаживаете свое приложение в Visual С++, нажмите F5 или зеленый треугольник на панели инструментов. Если вы на самом деле не отлаживаете его (у вас нет установленных точек останова), нажмите Ctrl + F5 или выберите "Начать без отладки" в меню (обычно это в меню "Отладка", которое, я согласен, сбивает с толку.) Это будет немного быстрее, и что более важно для вас, остановится в конце, если вам не придется менять свой код.
В качестве альтернативы откройте командную строку, перейдите в папку, в которой находится ваш exe, и запустите ее, набрав ее имя. Таким образом, когда он закончил выполнение командной строки, она не закрывается, и вы можете увидеть результат. Я предпочитаю оба этих метода добавлять код, который останавливает приложение так же, как и его завершение.
Ответ 11
Хорошо, я предполагаю, что вы работаете в Windows с помощью Visual Studio. почему? Хорошо, потому что если вы находитесь на какой-то ОС Linux, вы, вероятно, будете запускать ее с консоли.
В любом случае вы можете добавить crap в конец вашей программы, как предлагают другие, или просто нажать CTRL + F5 (начать без отладки), а Visual Studio покинет консоль до завершения.
Ответ 12
Добавьте следующие строки перед любой функцией exit() или перед любым return в main() :
Ответ 13
Просто добавьте следующее в конце своей программы. Он попытается зафиксировать некоторую форму ввода пользователя, таким образом, он не позволит автоматически закрывать консоль.
Ответ 14
Для Visual Studio (и только Visual Studio) следующий фрагмент кода дает вам приглашение "дождаться нажатия клавиши для продолжения", которое действительно ждет, когда пользователь будет явно нажимать новый ключ, сначала очистив входной буфер:
Обратите внимание, что для этого используется макрос tchar.h для совместимости с несколькими "наборами символов" (как их называет VС++).
Ответ 15
Ответ 16
Ответ 17
Посмотрите, есть ли у вашей IDE флажок в настройке проекта, чтобы окно оставалось открытым после завершения программы. Если нет, используйте std::cin.get(); для чтения символа в конце основной функции. Однако не забудьте использовать только линейный вход (std:: getline) или обрабатывать оставшиеся непрочитанные символы в противном случае (std:: ignore до новой строки), потому что иначе конец .get() будет читать только выведенный мусор непрочитанных ранее.
Ответ 18
Вы даже можете объявить целое число в начале вашей функции main() (скажем int a; ) и поместить std::cin >> a; непосредственно перед возвращаемым значением. Таким образом, программа будет работать до тех пор, пока вы не нажмете клавишу и не войдете.
Ответ 19
Это работает хорошо:
Если вы сначала очистите буфер, это не будет проблемой при чтении следующего. По какой-то причине cin.ignore(1) не работает, оно должно быть 2.
Ответ 20
Все, что вам нужно сделать, установите переменную для x, затем просто введите это перед возвратом 0;
Ответ 21
Вы всегда можете создать пакетный файл. Например, если ваша программа называется helloworld.exe, некоторый код будет:
Ответ 22
Я помещаю точку останова при последнем возврате 0 программы. Он отлично работает.
Ответ 23
Ответ 24
Я использовал cin.get() , и это сработало, но в один прекрасный день мне нужно было использовать еще один cin.get([Array Variable]) до этого, чтобы захватить строку строки с пустым символом в середине. поэтому cin.get() не закрыл окно командной строки. Наконец, я нашел другой способ: Нажмите CTRL + F5, чтобы открыть его во внешнем окне, а Visual Studio больше не контролирует его. Просто спросите вас о закрытии после запуска последних команд.
Ответ 25
Я просто делаю это:
Примечание: очистка буфера cin и это необходимо только в том случае, если вы использовали cin в какой-то момент раньше в вашей программе. Кроме того, использование std:: numeric_limits:: max(), вероятно, лучше, чем INT_MAX, но оно немного многословно и обычно не нужно.
Ответ 26
Я попытался добавить функцию getchar() в конец. Но это не сработало. Так что я сделал, добавлял две функции getchar() один за другим. Я думаю, что первый getchar() поглощает клавишу Enter , которую вы нажимаете после последнего ввода данных. Поэтому попробуйте добавить две функции getchar() вместо одной
Ответ 27
Аналогичная идея для ответа yeh, минимальная альтернатива.
Создайте пакетный файл со следующим содержимым:
Затем используйте командный файл.
Ответ 28
Я не заметил, что кто-то еще разместил это, так что вот оно.
Ответ 29
просто используйте cin.ignore() прямо перед возвратом 0; дважды
Ответ 30
Если вы используете Windows, вы можете сделать system("pause >nul"); или system("pause"); . Он запускает консольную команду для приостановки программы, пока вы не нажмете клавишу. >nul препятствует тому, чтобы он говорил Press any key to continue. .
exit Функция, объявленная в <stdlib.h> , завершает программу на C++. Значение, передаваемое в качестве аргумента, exit возвращается операционной системе в качестве кода возврата программы или кода выхода. Принято, чтобы нулевым кодом возврата обозначалось, что программа завершена успешно. Константы EXIT_FAILURE и EXIT_SUCCESS , также определенные в, можно использовать <stdlib.h> для обозначения успеха или неудачи программы.
Выдача return инструкции из main функции эквивалентна вызову exit функции с возвращаемым значением в качестве аргумента.
Функция abort
abort Функция, также объявленная в стандартном включаемом файле <stdlib.h> , завершает программу на C++. Разница между exit и заключается в том abort , что exit позволяет выполнять обработку завершения при завершении выполнения C++ (вызываются деструкторы глобальных объектов), но abort немедленно завершает программу. abort Функция обходит обычный процесс уничтожения инициализированных глобальных статических объектов. Он также обходит любую специальную обработку, указанную с помощью atexit функции.
Функция atexit
Используйте atexit функцию, чтобы указать действия, которые выполняются до завершения программы. Глобальные статические объекты, инициализированные до уничтожения вызова atexit , не будут уничтожены до выполнения функции выхода.
return в main
Выдача return инструкции из main функционально эквивалентна вызову exit функции. Рассмотрим следующий пример.
exit Операторы и return в предыдущем примере функционально идентичны. Как правило, для C++ требуются функции, которые возвращают типы, отличные от void возвращаемых значений. main Функция является исключением; она может завершаться без return оператора. В этом случае он возвращает зависящее от реализации значение для вызывающего процесса. return Оператор позволяет указать возвращаемое значение из main .
Уничтожение статических объектов
При вызове exit или выполнении return инструкции из main статические объекты уничтожаются в обратном порядке их инициализации (после вызова метода, atexit если он существует). В следующем примере показано выполнение такого процесса инициализации и удаления.
Пример
В следующем примере статические объекты sd1 и sd2 создаются и инициализируются перед записью в main . После завершения выполнения этой программы с помощью return инструкции сначала sd2 уничтожается, а затем sd1 . Деструктор класса ShowData закрывает файлы, связанные с этими статическими объектами.
Другой способ записать этот код — объявить объекты ShowData с областью видимости блока, в результате чего они будут удаляться при выходе из области.
Последняя категория инструкций управления порядком выполнения программы, которую мы рассмотрим, – это остановки. Остановка – это инструкция управления порядком выполнения программы, которая завершает программу. В C++ остановки реализованы как функции (а не как ключевые слова), поэтому наши инструкции остановки будут вызовами функций.
Давайте сделаем небольшой экскурс и вспомним, что происходит, когда программа завершается нормально. Когда функция main() завершается (либо достигая конца тела функции, либо с помощью инструкции return ), происходит ряд разных вещей.
Во-первых, поскольку мы выходим из функции, все локальные переменные и параметры функции уничтожаются (как обычно).
Затем вызывается специальная функция std::exit() со значением, возвращаемым из main() (код состояния), переданным в качестве аргумента. Так что же такое std::exit() ?
Функция std::exit()
std::exit() – это функция, которая вызывает нормальное завершение программы. Нормальное завершение означает, что программа завершилась ожидаемым образом. Обратите внимание, что термин «нормальное завершение» ничего не говорит о том, была ли работа программы успешной (для этого нужен код состояния). Например, предположим, что вы пишете программу, в которой ожидаете, что пользователь введет имя файла для обработки. Если пользователь ввел недопустимое имя файла, ваша программа, вероятно, вернет ненулевой код состояния, чтобы указать на состояние сбоя, но это всё равно будет нормальное завершение.
std::exit() выполняет ряд функций очистки. Сначала уничтожаются объекты со статической продолжительностью хранения. Затем выполняется дополнительная очистка файлов, если использовались какие-либо файлы. Наконец, управление возвращается обратно в ОС, а аргумент, переданный в std::exit() , используется в качестве кода состояния.
Явный вызов std::exit()
Хотя std::exit() при завершении функции main() вызывается неявно, она также может быть вызвана явно, чтобы остановить программу до того момента, как она завершится нормально. Когда std::exit() вызывается таким образом, вам нужно будет включить заголовок cstdlib .
Вот пример явного использования std::exit() :
Эта программа печатает:
Обратите внимание, что инструкции после вызова std::exit() никогда не выполняются, потому что программа уже завершена.
Хотя в приведенной выше программе мы вызываем std::exit() из функции main() , std::exit() можно вызвать из любой функции для завершения программы в необходимой точке.
Одно важное замечание о явном вызове std::exit() : std::exit() не очищает никакие локальные переменные (ни в текущей функции, ни в функциях вверх по стеку вызовов). По этой причине обычно лучше избегать вызова std::exit() .
Предупреждение
Функция std::exit() не очищает локальные переменные в текущей функции и в функциях выше по стеку вызовов.
std::atexit
Поскольку std::exit() завершает программу немедленно, вы можете перед завершением выполнить какую-либо очистку вручную (в приведенном выше примере мы вручную вызывали функцию cleanup() ). Поэтому программисту необходимо не забывать вручную вызывать функцию очистки перед каждым вызовом exit() .
Чтобы помочь в этом, C++ предлагает функцию std::atexit() , которая позволяет вам указать функцию, которая будет автоматически вызываться при завершении программы через std::exit() .
Эта программа имеет тот же вывод, что и предыдущий пример:
Так зачем вам это делать? Это позволяет вам указать функцию очистки в одном месте (возможно, в main ), а затем не беспокоиться о том, чтобы не забыть вызвать эту функцию явно перед вызовом std::exit() .
Для продвинутых читателей
В многопоточных программах вызов std::exit() может привести к сбою вашей программы (поскольку поток, вызывающий std::exit() , будет очищать статические объекты, к которым могут обращаться другие потоки). По этой причине в C++ появилась еще одна пара функций, которые работают аналогично std::exit() и std::atexit() , – std::quick_exit() и std::at_quick_exit() . std::quick_exit() завершает программу нормально, но не очищает статические объекты и может выполнять или не выполнять другие типы очистки. std::at_quick_exit() выполняет ту же роль, что и std::atexit() для программ, завершаемых с помощью std::quick_exit() .
std::abort и std::terminate
C++ также содержит две другие функции, связанные с остановкой.
Функция std::abort() вызывает аварийное завершение вашей программы. Аварийное завершение означает, что в программе произошла какая-то необычная ошибка времени выполнения, и программа не может продолжать работу. Например, к аварийному завершению попытка разделить на 0 приведет. std::abort() не выполняет никакой очистки.
Случаи, когда std::abort вызывается неявно, мы увидим в этой главе позже (7.17 – assert и static_assert ).
Функция std::terminate() обычно используется вместе с исключениями (мы рассмотрим исключения в следующей главе). Хотя std::terminate можно вызвать явно, она чаще вызывается неявно, когда исключение не обрабатывается (и в некоторых других случаях, связанных с исключениями). По умолчанию std::terminate() вызывает std::abort() .
Когда следует использовать остановки?
Короткий ответ: «почти никогда». В C++ уничтожение локальных объектов является важной частью C++ (особенно когда мы дойдем до классов), и ни одна из вышеупомянутых функций не очищает локальные переменные. Исключения – лучший и безопасный механизм обработки ошибок.
Лучшая практика
Используйте остановки только в том случае, если нет безопасного способа нормально вернуться из функции main . Если вы не отключили исключения, используйте их для безопасной обработки ошибок.
Я пытался, Application.Exit но он по-прежнему вызывает все дочерние окна и оповещения, и я не знаю, как использовать Environment.Exit и какое целое число вставить в него.
Кстати, всякий раз, когда мои формы вызывают событие formclosed или, form closing я закрываю приложение с помощью this.Hide() функции; Влияет ли это на поведение моего приложения сейчас?
То есть вы говорите, что скрываете только формы, а не закрываете их? Это, вероятно, причина, по которой приложение не закрывается, оно все еще имеет открытые (скрытые) формы. Тогда я должен заменить все это.Скрыть () на это. Закрыть ()? Разместите код, касающийся действий и событий Close.Завершает этот процесс и дает базовой операционной системе указанный код выхода. Это код для вызова, когда вы используете консольное приложение.
Эта статья, Application.Exit vs. Environment.Exit , указывает на хороший совет:
В вопросе не упоминалось завершение из-за ошибки, поэтому код выхода должен быть нулевым: Environment.Exit(0) любое ненулевое значение подразумевает код ошибки конкретного приложения, который может использоваться сценарием для выполнения соответствующих действий. (Это новый код и приложение WinForms, так что в этом случае это вряд ли имеет значение, но это полезно знать всем, кто пишет инструменты командной строки.) Environment.Exit можно использовать и для применения форм. Поправьте меня, если я ошибаюсь, но я думаю, что return заявление впоследствии улучшит этот подход. Как я понял код будет продолжать выполнение после Application.Exit() до в return заявлении.Я знаю, что это не та проблема, с которой вы столкнулись, однако еще одна причина, по которой это может произойти, заключается в том, что в вашем приложении открыт не фоновый поток.
Когда IsBackground это false будет держать вашу программу открыты до резьбы Завершает, если вы установите IsBackground на true резьбу не будет держать программу открытой. Такие вещи, как BackgroundWoker , ThreadPool и Task все внутренне используют поток с IsBackground установленным на true .
Все, что тебе нужно System.Environment.Exit(1);
И он использует системное пространство имен «using System», которое почти всегда присутствует при запуске проекта.
Его больше подходит только для консольных приложений. Следует отметить, что события FormClosing / FormClosed не будут вызываться для Environment.Exit, а также exitCode должен быть ненулевым, если произошла ошибка,Я бы выбрал одно из следующих:
для консольного приложения (работает также на winforms).
Environment.Exit (0) также работает для WinForms, существует приложение без каких-либо исключений.Кстати. всякий раз, когда мои формы вызывают событие formclosed или закрытия формы, я закрываю приложение с помощью функции this.Hide (). Влияет ли это на поведение моего приложения сейчас?
Если все ваше приложение всегда должно полностью завершаться всякий раз, когда ваша основная форма закрыта, вам следует просто удалить этот обработчик закрытой формы. Не отменяя это событие и просто позволяя им закрыться, когда пользователь закроет его, вы получите желаемое поведение. Что касается всех других форм, если вы не собираетесь снова показывать тот же экземпляр формы, вы просто позволяете им закрыться, вместо того, чтобы предотвращать закрытие и скрывать их. Если вы показываете их снова, то их можно скрыть.
Если вы хотите, чтобы пользователь мог щелкнуть «x» для основной формы, но оставить другую форму открытой и, по сути, стать «новой» основной формой, то это немного сложнее. В таком случае вам нужно будет просто скрыть свою основную форму, а не закрывать ее, но вам нужно будет добавить какой-то механизм, который фактически закроет основную форму, когда вы действительно хотите, чтобы ваше приложение заканчивалось. Если вы находитесь в такой ситуации, вам нужно добавить больше вопросов к вашему вопросу, описывающих, какие типы приложений должны и не должны завершать программу.
я попробовал приложения.Выход, но он по-прежнему вызывает все дочерние окна и оповещения, и я не знаю, как использовать окружающая среда.Выход и какое число ставить в него. Кстати, когда мои формы вызывают событие formclosed или form closing, я закрываю приложение с помощью . Это влияет на то, как мне сейчас вести себя?
завершает этот процесс и дает операционной системе указанный код выхода. Это код для вызова при использовании консольного приложения.
Я знаю, что это не проблема, но другая причина, это может произойти в фоновом потоке открыть в приложении.
, когда IsBackground is false он будет держать вашу программу открытой до завершения потока, если вы установите IsBackground to true поток не будет держать программу открытой. Такие вещи, как BackgroundWoker , ThreadPool и Task все внутренне используют поток с IsBackground значение true .
все, что вам нужно-это System.Environment.Exit(1);
и он использует пространство имен system "using System", которое почти всегда присутствует при запуске проекта.
кстати. всякий раз, когда мои формы вызывают formclosed или событие закрытия формы, я закрываю applciation этим.Скрыть() функция. Это влияет на то, как мне сейчас вести себя?
Если все ваше приложение должно всегда полностью завершаться всякий раз, когда ваша основная форма закрыта, вы должны просто удалите обработчик закрытой формы. Не отменяя это событие и просто позволяя им закрываться, когда пользователь закрывает его, вы получите желаемое поведение. Что касается всех других форм, Если вы не собираетесь показывать тот же самый экземпляр формы снова, вы просто позволяете им закрыться, вместо того, чтобы препятствовать закрытию и скрывать их. Если вы показываете их снова, то скрыть их может быть хорошо.
Если вы хотите, чтобы пользователь мог нажать "x" для вашей основной формы, но иметь другая форма остается открытой и, по сути, становится "новой" основной формой, тогда это немного сложнее. В таком случае вам нужно будет просто скрыть свою основную форму, а не закрывать ее, но вам нужно будет добавить какой-то механизм, который будет на самом деле закрыть главную форму, когда вы действительно хотите, чтобы ваше приложение до конца. Если это ситуация, в которой вы находитесь, вам нужно будет добавить более подробную информацию к вашему вопросу, описывающему, какие типы приложений должны и не должны заканчиваться программа.
Читайте также: