Jak zatrzymać natychmiastowe zamykanie aplikacji konsoli C ++?

Ostatnio próbowałem nauczyć się C ++ z tej strony . Niestety, ilekroć próbuję uruchomić jeden z przykładów kodu, widzę, że ten program jest otwarty na około pół sekundy, a następnie natychmiast się zamyka. Czy jest jakiś sposób, aby zatrzymać natychmiastowe zamykanie programu, abym mógł zobaczyć owoce mojego wysiłku?

Edycja: Jak słusznie zauważa Charles Bailey w komentarzu poniżej, nie zadziała to, jeśli buforowane są postacie stdini naprawdę nie ma dobrego sposobu na obejście tego. Jeśli korzystasz z podłączonego debugera, sugerowane rozwiązanie Johna Diblinga jest prawdopodobnie najczystszym rozwiązaniem twojego problemu.

Powiedziawszy, zostawię to tutaj i może ktoś inny uzna to za przydatne. Używałem go często jako szybkiego hacka podczas pisania testów podczas programowania.

Po zakończeniu mainfunkcji możesz zadzwonićstd::getchar();

Otrzyma to pojedynczy znak stdin, co da ci zachowanie „naciśnij dowolny klawisz, aby kontynuować” (jeśli naprawdę chcesz otrzymać komunikat „naciśnij dowolny klawisz”, musisz sam go wydrukować).

Trzeba #include <cstdio>za getchar.

Jeśli używasz Visual Studio i uruchamiasz aplikację konsolową z IDE:

naciśnięcie CTRL-F5 (uruchom bez debugowania) uruchomi aplikację i pozostanie otwarte okno konsoli, dopóki nie naciśniesz żadnego klawisza.

Rozwiązanie Jamesa działa na wszystkich platformach.

Alternatywnie Windowsmożesz także dodać następujące przed powrotem z mainfunkcji:

  system("pause");

Spowoduje to uruchomienie pausepolecenia czekającego na naciśnięcie klawisza, a także wyświetlenie miłej wiadomościPress any key to continue . . .

Jeśli używasz programu Microsoft Visual C ++ 2010 Express i napotykasz problem z tym, że CTRL + F5 nie działa w celu utrzymania konsoli otwartej po zakończeniu programu, spójrz na ten wątek MSDN .

Prawdopodobnie IDE jest skonfigurowane do zamykania konsoli po uruchomieniu CTRL + F5; w rzeczywistości „Pusty projekt” w Visual C ++ 2010 domyślnie zamyka konsolę. Aby to zmienić, wykonaj czynności sugerowane przez moderatora Microsoft:

Kliknij prawym przyciskiem myszy nazwę projektu i przejdź do strony Właściwości, rozwiń Właściwości konfiguracji -> Łącznik -> System, wybierz Konsolę (/ PODSYSTEM: KONSOLA) w menu rozwijanym Podsystem. Ponieważ domyślnie Pusty projekt tego nie określa.

Zazwyczaj po prostu stawiam punkt przerwania na main()zamykającym się nawiasie klamrowym. Kiedy koniec programu zostanie osiągnięty w jakikolwiek sposób, punkt przerwania uderzy i możesz ALT-Tab w oknie konsoli, aby wyświetlić wynik.

Dlaczego po prostu nie uruchomić programu z konsoli, tj. Uruchomić program z cmd.exe, jeśli używasz systemu Windows. W ten sposób okno pozostaje otwarte po zakończeniu programu.

[EDYCJA]: Kiedy używam KDevelop4, istnieje pełnoprawna instancja Bash (Linux CLI) działająca na zakładce na dole IDE. Tego używam w takich okolicznościach.

Przed końcem kodu wstaw następujący wiersz:

system("pause");

Pozwoli to zachować konsolę do momentu naciśnięcia klawisza.

#include <iostream>
#include <string>

using namespace std;

int main()
{
    string s;
    cout << "Please enter your first name followed by a newline\n";
    cin >> s;
    cout << "Hello, " << s << '\n';
    system("pause"); // <----------------------------------
    return 0; // This return statement isn't necessary
}

Zadzwoń cin.get();2 razy:

    //...
    cin.get();
    cin.get();
    return 0
}

Jeśli uruchomisz kod z kompetentnego IDE, takiego jak Code :: Blocks , IDE będzie zarządzać konsolą używaną do uruchamiania kodu, pozostawiając go otwartym po zamknięciu aplikacji. Nie chcesz dodawać specjalnego kodu, aby utrzymać konsolę otwartą, ponieważ uniemożliwi to jej poprawne działanie, gdy będziesz używać jej naprawdę poza IDE.

Okej, zgaduję, że korzystasz z systemu Windows za pomocą programu Visual Studio ... dlaczego? Cóż, ponieważ jeśli masz system operacyjny Linux, prawdopodobnie uruchomiłbyś go z konsoli.

W każdym razie możesz dodać bzdury na koniec programu, jak sugerują inni, lub możesz po prostu nacisnąć CTRL + F5 (zacznij bez debugowania), a Visual Studio opuści konsolę po zakończeniu.

Inną opcją, jeśli chcesz uruchomić wersję Debugowania i nie dodawać bzdur do kodu, jest otwarcie okna konsoli (Start -> Uruchom -> cmd) i przejście do katalogu wyjściowego Debugowania . Następnie wystarczy wpisać nazwę pliku wykonywalnego, aby uruchomić program do debugowania w konsoli. Następnie możesz użyć programu Visual Studio do dołączania do przetwarzania lub czegoś takiego, jeśli naprawdę chcesz.

#include "stdafx.h"
#include <iostream>
#include <conio.h>

using namespace std;

int main()
{

    cout << "Press any key to continue...";
    getch();

    return 0;
}

Nie zauważyłem, że ktoś to opublikował, więc oto jest.

Jeśli faktycznie debugujesz aplikację w Visual C ++, naciśnij klawisz F5 lub zielony trójkąt na pasku narzędzi. Jeśli tak naprawdę nie debugujesz go (nie masz ustawionych punktów przerwania), naciśnij Ctrl + F5 lub wybierz z menu opcję Rozpocznij bez debugowania (zwykle jest to menu Debugowanie, które, jak się zgadzam, jest mylące). Będzie trochę szybciej, i co ważniejsze dla ciebie, zatrzyma się na końcu bez konieczności zmiany kodu.

Możesz też otworzyć wiersz polecenia, przejść do folderu, w którym znajduje się plik exe, i uruchomić go, wpisując jego nazwę. W ten sposób po zakończeniu uruchamiania wiersz polecenia nie zamyka się i można wyświetlić wynik. Wolę obie te metody od dodania kodu, który zatrzymuje aplikację po zakończeniu.

Po prostu dodaj poniższe na końcu programu. Spróbuje przechwycić jakąś formę danych wejściowych użytkownika, dzięki czemu konsola nie zostanie automatycznie zamknięta.

cin.get();

Dodaj następujące wiersze przed dowolną exit()funkcją lub przed dowolnym returnw main():

std::cout << "Paused, press ENTER to continue." << std::endl;
cin.ignore(100000, "\n");

W przypadku programu Visual Studio (i tylko Visual Studio) następujący fragment kodu wyświetla monit o „poczekanie na naciśnięcie klawisza, aby kontynuować”, który naprawdę czeka na wyraźne naciśnięcie nowego klawisza przez użytkownika, najpierw opróżniając bufor wejściowy:

#include <cstdio>
#include <tchar.h>
#include <conio.h>

_tprintf(_T("Press a key to continue "));
while( _kbhit() /* defined in conio.h */ ) _gettch();
_gettch();

Zauważ, że dzięki temu tchar.hmakra są kompatybilne z wieloma „zestawami znaków” (jak je nazywa VC ++).

Po prostu to robię:

//clear buffer, wait for input to close program
std::cin.clear(); std::cin.ignore(INT_MAX, '\n');
std::cin.get();
return 0;

Uwaga: wyczyszczenie bufora cin i takie jest konieczne tylko wtedy, gdy użyłeś cin w pewnym momencie wcześniej w swoim programie. Również użycie std :: numeric_limits :: max () jest prawdopodobnie lepsze niż INT_MAX, ale jest nieco nieporadne i zwykle niepotrzebne.

Użyj #include "stdafx.h"i system("pause");tak jak kod poniżej.

#include "stdafx.h"
#include <iostream>
using namespace std;
int main()
{
    std::cout << "hello programmer!\n\nEnter 2 numbers: ";
    int x, y;
    std::cin >> x >> y;
    int w = x*y;
    std::cout <<"\nyour answer is: "<< w << endl;
    system("pause");
}

Podobny pomysł Yeh odpowiedź, tylko minimalistyczny alternatywą.

Utwórz plik wsadowy o następującej treści:

helloworld.exe
pause

Następnie użyj pliku wsadowego.

po prostu

#include <cstdio>

    int main(){
        // code...
        std::getchar();
        std::getchar();
        return 0;
    }

z jakiegoś powodu zwykle jest możliwe odczytanie 1 znaku za pomocą getchar już w standardowym czasie uruchamiania programu. więc pierwszy getchar odczytuje ten znak, a drugi getchar czeka na dane wejściowe użytkownika (twojego) przed wyjściem z programu. A po wyjściu programu z większości terminali, szczególnie w systemie Windows natychmiast zamknij terminal. dlatego naszym celem jest prosty sposób zapobiegania zakończeniu programu po wypisaniu wszystkiego. Oczywiście istnieją bardziej złożone i czyste sposoby rozwiązania tego, ale jest to najprostszy.

Sprawdź, czy IDE ma pole wyboru w ustawieniach projektu, aby okno pozostało otwarte po zakończeniu programu. Jeśli nie, użyj, std::cin.get();aby odczytać znak na końcu głównej funkcji. Pamiętaj jednak, aby używać wyłącznie wprowadzania liniowego (std :: getline) lub w przeciwnym razie radzić sobie z pozostałymi nieprzeczytanymi znakami (std :: ignoruj ​​do nowej linii), ponieważ w przeciwnym razie .get () na końcu odczyta tylko śmieci, które pozostawiłeś nieprzeczytane wcześniej.

To wydaje się działać dobrze:

cin.clear();
cin.ignore(2);

Jeśli najpierw wyczyścisz bufor, nie będzie problemu podczas czytania następnego. Z jakiegoś powodu cin.ignore(1)nie działa, musi być 2.

Zawsze możesz po prostu utworzyć plik wsadowy. Na przykład, jeśli Twój program nazywa się helloworld.exe, kod może wyglądać następująco:

@echo off
:1
cls
call helloworld.exe
pause >nul
goto :1

Jeśli używasz systemu Windows, możesz zrobić system("pause >nul");lub system("pause");. Wykonuje polecenie konsoli, aby wstrzymać program do momentu naciśnięcia klawisza. >nulzapobiega temu Press any key to continue....

Stawiam punkt przerwania przy ostatnim zwrocie 0 programu. To działa dobrze.

Użyłem cin.get()i to działa, ale pewnego dnia musiałem użyć innego cin.get([Array Variable]), aby złapać sznur molwy z pustym znakiem na środku. więc cin.get()nie uniknęło zamknięcia okna wiersza polecenia. Wreszcie znalazłem inny sposób: naciśnij CTRL + F5, aby otworzyć w oknie zewnętrznym, a Visual Studio nie ma już nad nim kontroli. Poprosi Cię tylko o zamknięcie po uruchomieniu ostatecznych poleceń.

Próbowałem umieścić getchar()funkcję na końcu. Ale to nie zadziałało. Więc dodałem dwie getchar()funkcje jedna po drugiej. Myślę, że pierwszy getchar()wchłania Enterklawisz, który naciskasz po ostatnim wprowadzeniu danych. Spróbuj więc dodać dwie getchar()funkcje zamiast jednej

Zamiast naciskać przycisk Uruchom, naciśnij jednocześnie CTRL i F5, da ci to dowolny klawisz, aby kontynuować wiadomość. Lub wpisz „(ostrzeżenie użyj tego tylko do testowania nie rzeczywistych programów, ponieważ antywirusy tego nie lubią !!!!)” na końcu swojej głównej funkcji, ale: (ostrzeżenie użyj tego tylko do testowania nie rzeczywistych programów jako antywirusów to ci się podoba !!!!)

po prostu użyj cin.ignore () tuż przed zwróceniem 0; dwa razy

main()
  {
  //your codes 

  cin.ignore();
  cin.ignore();

  return 0;
  }

to wszystko

Wszystko, co musisz zrobić, to ustawić zmienną dla x, a następnie po prostu wpisać ją przed wartością 0;

cout<<"\nPress any key and hit enter to end...";
cin>>x;

Możesz nawet zadeklarować liczbę całkowitą na początku swojej main()funkcji (powiedzmy int a;) i umieścić std::cin >> a;tuż przed wartością zwracaną. Tak więc program będzie działał, dopóki nie naciśniesz klawisza i nie wprowadzisz.