Comment arrêter la fermeture immédiate de l'application console C ++?

Dernièrement, j'ai essayé d'apprendre le C ++ à partir de ce site Web . Malheureusement, chaque fois que j'essaie d'exécuter l'un des exemples de code, je vois ce programme s'ouvrir pendant environ une demi-seconde, puis se fermer immédiatement. Existe-t-il un moyen d'empêcher la fermeture immédiate du programme afin que je puisse voir les fruits de mes efforts?

Edit: comme Charles Bailey le souligne à juste titre dans un commentaire ci-dessous, cela ne fonctionnera pas s'il y a des personnages en mémoire tampon stdin, et il n'y a vraiment pas de bon moyen de contourner cela. Si vous utilisez un débogueur attaché, la solution suggérée par John Dibling est probablement la solution la plus propre à votre problème.

Cela dit, je vais laisser cela ici et peut-être que quelqu'un d'autre le trouvera utile. Je l'ai beaucoup utilisé comme hack rapide lors de l'écriture de tests pendant le développement.

À la fin de votre mainfonction, vous pouvez appelerstd::getchar();

Cela obtiendra un seul caractère stdin, vous donnant ainsi le type de comportement "appuyez sur n'importe quelle touche pour continuer" (si vous voulez réellement un message "appuyez sur n'importe quelle touche", vous devrez en imprimer un vous-même).

Vous devez #include <cstdio>pour getchar.

Si vous utilisez Visual Studio et que vous démarrez l'application console à partir de l'EDI:

appuyer sur CTRL-F5 (démarrer sans débogage) démarrera l'application et gardera la fenêtre de la console ouverte jusqu'à ce que vous appuyiez sur une touche.

La solution de James fonctionne pour toutes les plateformes.

Alternativement, Windowsvous pouvez également ajouter les éléments suivants juste avant de revenir de la mainfonction:

  system("pause");

Cela exécutera la pausecommande qui attend que vous appuyiez sur une touche et affiche également un joli messagePress any key to continue . . .

Si vous utilisez Visual C ++ 2010 Express de Microsoft et rencontrez le problème avec CTRL + F5 ne fonctionnant pas pour garder la console ouverte après la fin du programme, jetez un œil à ce thread MSDN .

Votre IDE est probablement configuré pour fermer la console après une exécution CTRL + F5; en fait, un «projet vide» dans Visual C ++ 2010 ferme la console par défaut. Pour changer cela, faites comme suggéré par le modérateur Microsoft:

Cliquez avec le bouton droit sur le nom de votre projet et accédez à la page Propriétés, développez Propriétés de configuration -> Éditeur de liens -> Système, sélectionnez Console (/ SUBSYSTEM: CONSOLE) dans la liste déroulante Sous-système. Parce que, par défaut, le projet vide ne le spécifie pas.

Je mets habituellement juste un point d'arrêt sur main()l'accolade bouclée de fermeture. Lorsque la fin du programme est atteinte par quelque moyen que ce soit, le point d'arrêt va frapper et vous pouvez ALT-Tab à la fenêtre de la console pour afficher la sortie.

Pourquoi ne pas simplement exécuter le programme à partir d'une console, c'est-à-dire exécuter le programme à partir de cmd.exe si vous utilisez Windows. De cette façon, la fenêtre reste ouverte après la fin du programme.

[EDIT]: Lorsque j'utilise KDevelop4, il y a une instance à part entière de Bash (une CLI Linux) fonctionnant dans un onglet au bas de l'IDE. C'est ce que j'utilise dans ce genre de circonstances.

Avant la fin de votre code, insérez cette ligne:

system("pause");

Cela gardera la console jusqu'à ce que vous appuyiez sur une touche.

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

Appelez cin.get();2 fois:

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

Si vous exécutez votre code à partir d'un IDE compétent, tel que Code :: Blocks , l'IDE gérera la console qu'il utilise pour exécuter le code, en le gardant ouvert à la fermeture de l'application. Vous ne voulez pas ajouter de code spécial pour garder la console ouverte, car cela l'empêchera de fonctionner correctement lorsque vous l'utiliserez pour de vrai, en dehors de l'EDI.

D'accord, je suppose que vous utilisez Windows avec Visual Studio ... pourquoi? Eh bien parce que si vous utilisez un système d'exploitation Linux, vous l'exécuterez probablement à partir de la console.

Quoi qu'il en soit, vous pouvez ajouter de la merde à la fin de votre programme comme d'autres le suggèrent, ou vous pouvez simplement appuyer sur CTRL + F5 (démarrer sans débogage) et Visual Studio quittera la console une fois terminée.

Une autre option si vous souhaitez exécuter la version de débogage sans ajouter de conneries à votre code consiste à ouvrir la fenêtre de la console (Démarrer -> Exécuter -> cmd) et à naviguer vers votre répertoire de sortie de débogage . Ensuite, entrez simplement le nom de votre exécutable et il exécutera votre programme de débogage dans la console. Vous pouvez ensuite utiliser l'attachement de Visual Studio pour traiter ou quelque chose si vous le souhaitez vraiment.

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

using namespace std;

int main()
{

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

    return 0;
}

Je n'ai pas remarqué que quelqu'un d'autre a posté cela, alors le voici.

Si vous déboguez réellement votre application dans Visual C ++, appuyez sur F5 ou sur le triangle vert de la barre d'outils. Si vous ne le déboguez pas vraiment (vous n'avez pas de points d'arrêt définis), appuyez sur Ctrl + F5 ou choisissez Démarrer sans débogage dans les menus (c'est généralement dans le menu Déboguer, ce qui, je le reconnais, prête à confusion). Ce sera un peu plus rapide, et plus important pour vous, s'arrêtera à la fin sans que vous ayez à changer votre code.

Sinon, ouvrez une invite de commande, accédez au dossier où se trouve votre exe et exécutez-le en tapant son nom. De cette façon, une fois l'exécution terminée, l'invite de commande ne se ferme pas et vous pouvez voir la sortie. Je préfère ces deux méthodes à l'ajout de code qui arrête l'application au moment où elle est terminée.

Ajoutez simplement ce qui suit à la fin de votre programme. Il essaiera de capturer une certaine forme d'entrée utilisateur, empêchant ainsi la console de se fermer automatiquement.

cin.get();

Ajoutez les lignes suivantes avant toute exit()fonction ou avant tout returns dans main():

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

Pour Visual Studio (et uniquement Visual Studio), l'extrait de code suivant vous donne une invite `` attendre que la pression sur la touche continue '' qui attend vraiment que l'utilisateur appuie explicitement sur une nouvelle touche, en vidant d'abord le tampon d'entrée:

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

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

Notez que cela utilise les tchar.hmacros pour être compatible avec plusieurs «jeux de caractères» (comme VC ++ les appelle).

Je fais juste ceci:

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

Remarque: l'effacement du tampon cin et ainsi de suite n'est nécessaire que si vous avez utilisé cin à un moment donné plus tôt dans votre programme. Utiliser également std :: numeric_limits :: max () est probablement mieux que INT_MAX, mais c'est un peu verbeux et généralement inutile.

Utilisez #include "stdafx.h"& system("pause");comme le code ci-dessous.

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

Idée similaire à yeh réponse, juste solution minimaliste.

Créez un fichier de commandes avec le contenu suivant:

helloworld.exe
pause

Utilisez ensuite le fichier batch.

simplement

#include <cstdio>

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

pour une raison quelconque, il est généralement possible de lire 1 caractère avec getchar déjà dans stdin lorsque vous exécutez un programme. donc le premier getchar lit ce caractère, et le second getchar attend l'entrée utilisateur (votre) avant de quitter le programme. Et après qu'un programme quitte la plupart des terminaux, en particulier sur Windows, fermez immédiatement le terminal. donc ce que nous visons est un moyen simple d'empêcher un programme de se terminer après avoir tout sorti. Bien sûr, il existe des moyens plus complexes et plus propres de résoudre ce problème, mais c'est le plus simple.

Vérifiez si votre IDE a une case à cocher dans le paramètre de projet pour garder la fenêtre ouverte après la fin du programme. Sinon, utilisez std::cin.get();pour lire un caractère à la fin de la fonction principale. Cependant, assurez-vous d'utiliser uniquement une entrée basée sur la ligne (std :: getline) ou de traiter les restes de caractères non lus sinon (std :: ignore jusqu'à la nouvelle ligne) car sinon le .get () à la fin ne lira que les ordures que vous avez laissées non lu plus tôt.

Cela semble bien fonctionner:

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

Si vous effacez d'abord le tampon, ce ne sera pas un problème lorsque vous lirez le suivant. Pour une raison quelconque, cin.ignore(1)cela ne fonctionne pas, il doit être 2.

Vous pouvez toujours simplement créer un fichier de commandes. Par exemple, si votre programme s'appelle helloworld.exe, du code serait:

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

Si vous exécutez Windows, vous pouvez faire system("pause >nul");ou system("pause");. Il exécute une commande de console pour suspendre le programme jusqu'à ce que vous appuyiez sur une touche. >null'empêche de dire Press any key to continue....

Je mets un point d'arrêt au dernier retour 0 du programme. Ça fonctionne bien.

J'ai utilisé cin.get()et cela fonctionne, mais un jour, j'ai dû en utiliser un autre cin.get([Array Variable])avant cela pour saisir une chaîne ling avec un caractère vide au milieu de. la cin.get()fenêtre d'invite de commande n'a donc pas été fermée. Enfin, j'ai trouvé une autre façon: appuyez sur CTRL + F5 pour ouvrir dans une fenêtre externe et Visual Studio n'a plus de contrôle sur elle. Je vais juste vous poser des questions sur la fermeture après l'exécution des dernières commandes.

J'ai essayé de mettre une getchar()fonction à la fin. Mais ça n'a pas marché. J'ai donc ajouté deux getchar()fonctions l'une après l'autre. Je pense que le premier getchar()absorbe la Entertouche sur laquelle vous appuyez après la dernière entrée de données. Essayez donc d'ajouter deux getchar()fonctions au lieu d'une

Au lieu d'appuyer sur le bouton d'exécution, appuyez sur CTRL et F5 en même temps, il vous donnera la touche n'importe quelle touche pour continuer le message. Ou tapez "(avertissement utilisez ceci uniquement pour tester des programmes non réels car un antivirus ne l'aime pas !!!!)" à la fin de votre fonction principale mais: (avertissement utilisez ceci uniquement pour tester des programmes non réels comme un antivirus ne le faites pas 'aime pas !!!!)

utilisez simplement cin.ignore () juste avant de retourner 0; deux fois

main()
  {
  //your codes 

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

  return 0;
  }

c'est tout

Il vous suffit de définir une variable pour x, puis de la saisir avant le retour 0;

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

Vous pouvez même déclarer un entier au début de votre main()fonction (disons int a;) et le mettre std::cin >> a;juste avant la valeur de retour. Ainsi, le programme continuera de fonctionner jusqu'à ce que vous appuyiez sur une touche et entriez.