Y at-il une fonction d'attente décente en C ++?

Question

L'une des premières choses que j'ai appris en C ++ est que

#include <iostream>
int main()
{
    std::cout<<"Hello, World!\n";
    return 0;
}

serait simplement apparaître et disparaître très rapidement sans pause. Pour éviter cela, je devais aller à bloc-notes et enregistrer

helloworld.exe
pause

ase

helloworld.bat

a fastidieux quand je besoin de créer un tas de petits programmes de test, et finalement je simplement mis while(true); à la fin sur la plupart de mes programmes de test, juste pour que je puisse voir les résultats. Y at-il une meilleure fonction d'attente que je peux utiliser?

Answer 1

vous pouvez demander à l'utilisateur de frapper entrer avant de fermer le programme ... quelque chose comme cela fonctionne.

#include <iostream>
int main()
{
  std::cout << "Hello, World\n";
  std::cin.ignore();
  return 0;
}

Le cin lit dans l'entrée utilisateur et la fonction .ignore () de cin indique au programme d'ignorer l'entrée. Le programme se poursuivra lorsque l'utilisateur clique entrer.

lien

Answer 2

Beaucoup de gens ont suggéré sleep POSIX, Windows Sleep, Windows system("pause"), C ++ cin.get() ... il y a même un getch() DOS là-bas, à partir de fin des années 1920 à peu près.

S'il vous plaît ne font aucun d'entre eux.

Aucune de ces solutions passerait revue de code dans mon équipe. Cela signifie que, si vous avez soumis ce code à inclure dans nos produits, votre engagement serait bloqué et vous seriez dit d'aller trouver une autre solution. (On pourrait dire que les choses ne sont pas si sérieux quand vous êtes juste un amateur à jouer autour, mais je propose de développer de bonnes habitudes dans vos projets pour animaux de compagnie est ce que vous fera un professionnel apprécié dans une organisation commerciale, et vous garder embauché. )

Garder ouvrir la fenêtre de la console, vous pouvez donc lire la sortie de votre programme est pas la responsabilité de votre programme! Lorsque vous ajoutez une attente / veille / bloc à la fin de votre programme, vous violez le principe de responsabilité unique, ce qui crée une fuite d'abstraction massive et oblitérer la réutilisation / chainability de votre programme. Il ne prend plus de temps d'entrée et donne une sortie - il bloque pour des raisons d'utilisation transitoire. Ceci est très bien non.

Au lieu de cela, vous devez configurer votre environnement pour garder l'ouverture rapide après votre programme a terminé ses travaux. Votre wrapper lot de script est une bonne approche! Je peux voir comment il serait ennuyeux d'avoir à maintenir la mise à jour manuellement, et vous ne pouvez pas l'appeler à partir de votre IDE. Vous pouvez faire le script prendre le chemin du programme à exécuter en tant que paramètre et configurer votre IDE pour l'appeler au lieu de votre programme directement.

Une intérimaire, l'approche de démarrage rapide serait de modifier ordre de marche de votre IDE de cmd.exe <myprogram> ou <myprogram>, à cmd.exe /K <myprogram>. Le commutateur de /K à cmd.exe rend le séjour rapide ouvert après le programme au chemin donné a pris fin . Cela va être un peu plus ennuyeux que votre solution batch script, parce que maintenant vous devez taper exit ou cliquez sur le « X » rouge lorsque vous avez terminé la lecture de la sortie de votre programme, plutôt que de simplement claquant la barre d'espace.

---

^{Je suppose l'utilisation d'un IDE, parce que sinon vous invoquez déjà à partir d'une invite de commande, et ce ne serait pas un problème en premier lieu. De plus, je suppose que l'utilisation de Windows (basé sur le détail dans la question), mais cette réponse s'applique à toute plate-forme ... qui est, soit dit en passant, la moitié du point.}

Answer 3

S'il vous plaît noter que le code ci-dessus a été testé sur Code :: Blocks 12,11 et Visual Studio 2012 | sur Windows 7.

Pour forcer votre arrêt du programme ou attendez, vous avez plusieurs options:

---

• sommeil (unsigned int)

La valeur doit être un nombre entier positif dans la milliseconde. Cela signifie que si vous voulez que votre programme attendez 2 secondes, entrez 2000.

Voici un exemple:

#include <iostream>     //for using cout
#include <stdlib.h>     //for using the function sleep

using namespace std;    //for using cout

int main(void)         
{
   cout << "test" << endl;
   sleep(5000);         //make the programme waiting for 5 seconds
   cout << "test" << endl;
   sleep(2000);         // wait for 2 seconds before closing

   return 0;
}

Si vous attendez trop longtemps, cela signifie probablement le paramètre est en secondes. Donc changer à ceci:

sleep(5);

Pour ceux qui obtiennent un message d'erreur ou d'un problème à l'aide essayer le sommeil de le remplacer par _sleep ou sommeil en particulier sur le Code :: Bloks.
Et si vous obtenez toujours des problèmes, essayez d'ajouter d'une cette bibliothèque au début du code.

#include <stdio.h>
#include <time.h>
#include <unistd.h>
#include <dos.h>
#include <windows.h>

---

• système ( "PAUSE")

Un programme simple « Bonjour tout le monde » sur les fenêtres de l'application console serait probablement proche avant de pouvoir voir quoi que ce soit. Que le cas où vous pouvez utiliser le système ( « Pause »).

#include <iostream>    

using namespace std;   

int main(void)         
{
    cout << "Hello world!" << endl;

    system("PAUSE");

    return 0;
}

Si vous obtenez le message « erreur: « système » n'a pas été déclaré dans ce champ » il suffit d'ajouter la ligne suivante à la biggining du code:

#include <cstdlib>

---

• cin.ignore ()

Le même résultat peut être atteint en utilisant cin.ignore ():

#include <iostream>     

using namespace std;    

int main(void)         
{
    cout << "Hello world!" << endl;

    cin.ignore();

    return 0;
}

---

• cin.get ()

exemple:

#include <iostream>     

using namespace std;    

int main(void)         
{
    cout << "Hello world!" << endl;

    cin.get();

    return 0;
}

---

• getch ()

Il suffit de ne pas oublier d'ajouter la bibliothèque conio.h:

#include <iostream>     
#include <conio.h>    //for using the function getch()

using namespace std;    

int main(void)
{

    cout << "Hello world!" << endl;

    getch();

    return 0;
}

Vous pouvez avoir un message vous indiquant d'utiliser _getch () insted de getch

Answer 4

L'apparition et la disparition d'une fenêtre pour l'affichage du texte est une caractéristique de la façon dont vous exécutez le programme, pas de C ++.

Exécuter dans un environnement de ligne de commande persistante, ou d'inclure le soutien fenêtrage votre programme, ou utilisez sleep ou attendre sur l'entrée comme indiqué dans d'autres réponses.

Answer 5

l'équivalent au programme de traitement par lots serait

#include<iostream>
int main()
{
    std::cout<<"Hello, World!\n";
    std::cin.get();
    return 0;
}

La ligne supplémentaire fait exactement ce PAUSE le fait, attend une seule entrée de caractères

Answer 6

En fait, contrairement aux autres réponses, je crois que la solution de l'OP est celle qui est la plus élégante.

Voici ce que vous gagnez en utilisant une enveloppe de .bat externe:

1. L'application attend évidemment pour l'entrée de l'utilisateur, il fait déjà ce que vous voulez.
2. Vous ne polluez pas le code avec des appels maladroits. Qui devrait attendre? main()?
3. Vous n'avez pas besoin de traiter des questions multiplateformes - voir combien de personnes suggéré system("pause") ici
.
4. Sans cela, pour tester votre exécutable de manière automatique dans le modèle de test boîte noire, vous devez simuler la pression de touche de enter (sauf si vous faites les choses mentionnées dans la note).
5. Peut-être le plus important - devrait tout utilisateur vouloir exécuter votre application à travers le terminal (cmd.exe sur la plate-forme Windows), ils ne pas veulent attendre, car ils verront la sortie de toute façon. Avec la technique d'emballage de .bat, ils peuvent décider d'exécuter l'emballage .bat (ou .sh), ou exécuter l'exécutable directement.

En se concentrant sur les deux derniers points - avec une autre technique, je pense que le programme offre interrupteur au moins de --no-wait en sorte que, en tant qu'utilisateur, pouvez utiliser l'application avec toutes sortes d'opérations telles que la tuyauterie de la sortie, enchaînant avec d'autres programmes, etc. Ceux-ci font partie du flux de travail de CLI normale, et en ajoutant attente à la fin quand vous êtes déjà à l'intérieur d'un terminal devient juste de la manière et détruit l'expérience utilisateur.

Pour ces raisons, l'OMI solution .bat est la plus belle ici.

Answer 7

Il y a une façon 11 C ++ de le faire. Il est assez simple, et je crois qu'il est portable. Bien sûr, comme Légèreté Courses en orbite a souligné, vous ne devriez pas faire cela afin de pouvoir voir un Bonjour tout le monde dans votre terminal, mais il existe une bonne raison d'utiliser une fonction d'attente. Sans plus tarder,

#include <chrono> // std::chrono::microseconds
#include <thread> // std::this_thread::sleep_for
std::this_thread::sleep_for(std::chrono::microseconds{});

Plus de détails sont disponibles . Voir aussi sleep_until .

Answer 8

Qu'est-ce que vous avez peut être écrit plus facile. Au lieu de:

#include<iostream>
int main()
{
    std::cout<<"Hello, World!\n";
    return 0;
}

écriture

#include<iostream>
int main()
{
    std::cout<<"Hello, World!\n";
    system("PAUSE");
    return 0;
}

La fonction système exécute tout ce que vous donnez comme s'il a été écrit dans l'invite de commande. Il suspend l'exécution de votre programme alors que la commande est en cours d'exécution, vous pouvez donc faire quelque chose avec elle, vous pouvez même compiler des programmes à partir de votre programme cpp.

Answer 9

Syntaxe:

sommeil vide (non signés seconde);

sleep () suspend l'exécution pendant un intervalle (secondes). Avec un appel à dormir, le programme en cours est suspendu à l'exécution pour le nombre de secondes spécifié par les secondes argument. L'intervalle est exact seulement au centième de seconde près ou à l'exactitude de l'horloge du système d'exploitation, selon le moins précis.

Cet exemple devrait préciser:

#include <dos.h>
#include <stdio.h>
#include <conio.h>

int main()
{
   printf("Message 1\n");
   sleep(2); //Parameter in sleep is in seconds
   printf("Message 2 a two seconds after Message 1");
   return 0;
}

Rappelez-vous que vous avez à #inclure dos.h

EDIT:

Vous pouvez également utiliser WinAPI.

VOID WINAPI Sleep(
DWORD dwMilliseconds
);

Fonction sommeil (Windows)

Juste une note, le paramètre dans la fonction fournie par winapi est en millisecondes, de sorte que la ligne de sommeil à l'extrait de code serait au-dessus de ressembler à ceci « Sommeil (2000); »

Answer 10

getchar () fournit une réponse simpliste (d'attente pour l'entrée du clavier). Sommeil appel (millisecondes) pour dormir avant la sortie. fonction de mise en veille (MSDN)

Answer 11

Vous pouvez utiliser sleep () ou usleep ().

// Wait 5 seconds
sleep( 5 );

Answer 12

Eh bien, c'est un ancien poste mais je vais simplement contribuer à la question - quelqu'un peut être utile plus tard:

ajoutant 'cin.get ();' fonction juste avant le retour de la main () semble toujours arrêter le programme de sortir avant d'imprimer les résultats: voir exemple de code ci-dessous:

int main () {       chaîne fname, lname;

  //ask user to enter name first and last name
  cout << "Please enter your first name: ";
  cin >> fname;

  cout << "Please enter your last name: ";
  cin >> lname;     
  cout << "\n\n\n\nyour first name is: " << fname << "\nyour last name is: " 
  << lname <<endl;

  //stop program from exiting before printing results on the screen
  cin.get();
  return 0;

}

Answer 13

Avant la déclaration de retour en vous principal, insérez ce code:

Système ( "pause")

tiendra la console jusqu'à ce que vous appuyez 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
}

Answer 14

La deuxième chose à apprendre (on pourrait faire valoir que cela devrait être le premier) est l'interface de ligne de commande de votre système d'exploitation et compilateur / éditeur de liens drapeaux et commutateurs.