Jak utrzymać otwarte okno konsoli w Visual C ++?

Zaczynam od Visual C ++ i chciałbym wiedzieć, jak zachować okno konsoli.

Na przykład byłaby to typowa aplikacja „hello world”:

int _tmain(int argc, _TCHAR* argv[])
{
    cout << "Hello World";
    return 0;
}

Jakiego wiersza mi brakuje?

Rozpocznij projekt Ctrl+F5zamiast zamiast F5.

Okno konsoli pozostanie otwarte z Press any key to continue . . .komunikatem po wyjściu z programu.

Pamiętaj, że wymaga to Console (/SUBSYSTEM:CONSOLE)opcji linkera, którą możesz włączyć w następujący sposób:

1. Otwórz swój projekt i przejdź do Eksploratora rozwiązań. Jeśli podążasz za mną w K&R, Twoim „rozwiązaniem” będzie „cześć” z 1 projektem pod nim, a także „cześć” pogrubioną czcionką.
2. Kliknij prawym przyciskiem myszy „cześć” (lub dowolną nazwę projektu).
3. Wybierz „Właściwości” z menu kontekstowego.
4. Wybierz Właściwości konfiguracji> Linker> System.
5. Aby wyświetlić właściwość „Podsystem” w prawym panelu, kliknij menu rozwijane w prawej kolumnie.
6. Wybierz „Console (/ SUBSYSTEM: CONSOLE)”
7. Kliknij Zastosuj, poczekaj, aż skończy to, co robi, a następnie kliknij OK. (Jeśli opcja „Zastosuj” jest wyszarzona, wybierz inną opcję podsystemu, kliknij przycisk Zastosuj, a następnie wróć i zastosuj opcję konsoli. Z mojego doświadczenia wynika, że ​​sama OK nie zadziała).

CTRL-F5 i wskazówki do podsystemu działają razem; nie są osobnymi opcjami.

(Dzięki uprzejmości DJMorreTX z http://social.msdn.microsoft.com/Forums/en-US/vcprerelease/thread/21073093-516c-49d2-81c7-d960f6dc2ac6 )

Standardowy sposób jest cin.get()przed zwrotem.

int _tmain(int argc, _TCHAR* argv[])
{
    cout << "Hello World";
    cin.get();
    return 0;
}

Umieść punkt przerwania na returnlinii.

Używasz go w debuggerze, prawda?

Inną opcją jest użycie

#include <process.h>
system("pause");

Chociaż nie jest to zbyt przenośne, ponieważ będzie działać tylko w systemie Windows, ale zostanie automatycznie wydrukowane

Naciśnij dowolny klawisz, aby kontynuować...

W przypadku projektów makefile zaakceptowane rozwiązanie kończy się niepowodzeniem z powodu błędu w programie Visual Studio (który jest obecny przynajmniej do wersji 2012 - nie testowałem jeszcze 2013). Ten błąd jest szczegółowo opisany tutaj .

Aby zatrzymać konsolę po zakończeniu programu w projekcie makefile, wykonaj następujące kroki (może się to różnić w przypadku wersji innych niż 2010-2012):

1) Przejdź /SUBSYSTEM:CONSOLEdo linkera. - EDYCJA : patrz poniżej.

2) Otwórz plik projektu (.vcxproj) w edytorze tekstu.

3) Wewnątrz <project>znacznika głównego wstaw następujące elementy:

<ItemDefinitionGroup>
  <Link>
    <SubSystem>Console</SubSystem>
  </Link>
</ItemDefinitionGroup>

4) Załaduj ponownie projekt do swojego rozwiązania.

5) Uruchom program bez debugowania (CTRL + F5).

EDYTOWAĆ:

Zgodnie z moim komentarzem poniżej ustawienie opcji linkera /SUBSYSTEM:CONSOLEjest w rzeczywistości nieistotne dla projektów makefile (i niekoniecznie nawet możliwe, jeśli używasz kompilatora innego niż MSVC). Liczy się tylko to, że ustawienie zostanie dodane do pliku .vcxproj, jak w kroku 3 powyżej.

Możesz użyć cin.get();lub cin.ignore();tuż przed instrukcją return, aby uniknąć zamknięcia okna konsoli.

po prostu umieść punkt przerwania na ostatnim kręconym nawiasie głównym.

    int main () {
       //...your code...
       return 0;
    } //<- breakpoint here

działa dla mnie, nie ma potrzeby uruchamiania bez debugowania. Wykonuje także destruktory przed trafieniem do punktu przerwania, dzięki czemu można sprawdzić wszelkie komunikaty wydrukowane na tych destrukterach, jeśli takie istnieją.

Po prostu dodaj punkt przerwania do nawiasu zamykającego _tmainmetody. Jest to łatwiejszy sposób i nie trzeba dodawać kodu w celu debugowania.

Umieść punkt przerwania na końcowym nawiasie klamrowym main(). Potknie się nawet przy wielu returninstrukcjach. Jedynym minusem jest to, że wezwanie doexit() nie zostanie złapane.

Jeśli nie debugujesz, postępuj zgodnie ze wskazówkami zawartymi w odpowiedzi Zoidberga i uruchom program za pomocą Ctrl+ F5zamiast po prostu F5.

Moje 2 centy:

Wybór 1: Dodaj punkt przerwania na końcu main()

Wybór 2: Dodaj ten kod, tuż przed return 0;:

std::cout << "Press ENTER to continue..."; //So the User knows what to do
std::cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n');

Musisz uwzględnić <iomanip>dlastd::numeric_limits

po prostu dodaj system („pauza”) na końcu kodu, zanim zwróci 0 w ten sposób

#include <stdlib.h>

int main()
{
    //some code goes here
    system("pause")
    return 0;
}

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

cin.get()Lub system("PAUSE"). Nie słyszałem, że możesz użyćreturn(0);

Dołączam, #include <conio.h>a następnie dodaję getch();tuż przed return 0;wierszem. Tego i tak nauczyłem się w szkole. Metody wymienione powyżej są zupełnie inne, widzę.

Miałem ten sam problem. Używam _getch()tuż przed instrukcją return. To działa.

(Niektóre opcje mogą być wywoływane różnymi nazwami. Nie używam wersji angielskiej)

Miałem ten sam problem, kiedy tworzyłem projekty z opcją „pusty projekt”, Utwórz projekt jako „Aplikacja konsoli Win32” zamiast „pusty projekt”. W wyświetlonym oknie dialogowym naciśniesz „kontynuuj”, a następnie możesz zaznaczyć opcję „pusty projekt” i nacisnąć przycisk potwierdzenia. Następnie CTRL + F5 otworzy konsolę, która nie zamyka się automatycznie.

Miałem ten sam problem; W mojej aplikacji jest wiele punktów wyjścia () i nie było sposobu, aby wiedzieć, gdzie dokładnie wychodzi, wtedy dowiedziałem się o tym:

atexit(system("pause"));

lub

atexit(cin.get());

W ten sposób przestanie działać bez względu na to, gdzie wyjdziemy z programu.

Inna opcja:

#ifdef _WIN32
#define MAINRET system("pause");return 0
#else
#define MAINRET return 0
#endif

Głównie:

int main(int argc, char* argv[]) {
    MAINRET;
}

W rzeczywistości prawdziwym rozwiązaniem jest wybór samego szablonu projektu. MUSISZ wybrać aplikację konsoli Win32 w starszym VS lub wypełnić najpierw nazwę projektu, a następnie dwukrotnie kliknąć kreatora pulpitu systemu Windows, a następnie wybrać aplikację konsoli Win32. Następnie wybierz pusty projekt w tym momencie. Pozwala to na to, czego naprawdę chciał pierwotny pytający bez dodawania dodatkowego punktu zatrzymania i kodu wstrzymania. Przeszedłem również przez ten problem. Odpowiedź znajduje się również na stronie MSDN.

Oto sposób na pozostawienie otwartego okna poleceń bez względu na to, jak wykonanie się zatrzymuje bez modyfikowania kodu:

W Visual Studio otwórz Strony właściwości projektu -> Debugowanie .

W polu Command wpisz$(ComSpec)

W polu Argumenty poleceń wprowadź /k $(TargetPath). Dołącz dowolne argumenty do własnej aplikacji.

Teraz F5 lub Ctrl-F5 wykonuje Windows / System32 / cmd.exe w nowym oknie, a / k zapewnia, że wiersz polecenia pozostanie otwarty po zakończeniu wykonywania.

Minusem jest to, że wykonanie nie kończy się na punktach przerwania.

Jak niektórzy już zauważyli, rozwiązanie Zoidbergs nie dołącza debuggera, czego zwykle nie chcesz.

Najlepszą opcją imo jest odpowiednie skonfigurowanie VS (od VS 2017 r.), Przechodząc do Narzędzia> Opcje> Debugowanie> Ogólne. Tam odznaczasz „Automatycznie zamykaj konsolę po zatrzymaniu debugowania” (na samym dole), co prawdopodobnie jest zaznaczone w twoim przypadku.

możesz po prostu umieścić keep_window_open (); przed powrotem tutaj jest jeden przykład

int main()
{
    cout<<"hello world!\n";
    keep_window_open ();
    return 0;
}