C++. Program selfkills when I run it [duplicate] - c++

This question already has answers here:
Closed 10 years ago.
Possible Duplicate:
How to stop C++ console application from exiting immediately?
I am a newbie on C++. Following tutorials, my program selfkilled when it finished executing simple commands (like cout ans stuff). I discovered the get.cin() function that avoided that. However, anytime I use 'cin' commands to insert variables, the program selfkills just after receiving the input and executing the work. Is there a way to avoid that? thanks a lot!

The reason it quits when your program receives input, even though you are using std::cin.get() is because whenever cin reads input, there's a chance that some junk is left behind; when you call std::cin.get(), you will get that junk.
What you have to do is clear cin of any undesired data, such that std::cin.get() has nothing to read and is required to wait for new input.
...
std::cin.clear();
std::cin.get();
return 0;

A program doesn't "kill itself". It just exits when it has finished doing everything it was supposed to do (i.e. when you return from main).
It is up to you to set up your work environment so that you can see the output of a program. For example, if you are in Windows, you could open your own command line (run cmd) and run your program from there; or instruct your IDE to not close the terminal window after the program exits.

Your program doesn't kill itself after execution, it just ends it.
Simple example:
#include <iostream>
int main( int argc, const char* argv[] )
{
std::cout << "Hello, World" << std::endl;
return 0; // End of execution
}
In that example a small window opens then close very fast because the logic of the code says so, However in the next example:
#include <iostream>
int main( int argc, const char* argv[])
{
std::cout <<"Hello, World!" << std::endl;
std::cin.get();
return 0;
}
Your application will still be showing in the screen until you press enter key 'Return key' then it will exit.
In case you are using Windows Operating System, consider the next example:
#include <iostream>
int main( int argc, const char* argv[])
{
std::cout << "Hello, World!" << std::endl;
system("PAUSE");
return 0;
}
Please note that system("PAUSE") is in Windows only and won't run on other operating systems.
One more thing worth mentioning here, there are a lot of methods to use other that these, but I wrote the most common ones.

In some windowing systems, a console window is created when your program executes. When your program finishes, this console window disappears.
I always recommend the "pause" pattern to newbies:
cout << "Paused. Press ENTER to continue.\n");
cin.ignore(10000, '\n'); // Ignore until 100000 characters are entered or a newline is entered.
Sometimes, I make this into a function:
void Pause(void)
{
cout << "Paused. Press ENTER to continue.\n");
cin.ignore(10000, '\n'); // Ignore until 100000 characters are entered or a newline is entered.
}
Hope this helps,

std::cin.get() work well and its usage is pretty easy but it expect user to press return.
I used to end my program using ESC, so it won't work for me, so I use this
#ifdef _WIN32
std::system( "pause" );
#else
std::system( "read -n1 -r -p \"Press any key to continue...\"" );
#endif
It would print "Press any key to continue..." and continue execution with pressing any key so I can use my lovely ESC

Related

C++ Program AutoClosing when Main() function completes

I wrote a simple calculator program in C++ with Code::Blocks. When I compile the program, it runs fine through Code::Blocks, and ends with a press enter to continue, and then you can exit. However, when the exe is run manually, supose for a demo, then the program works fine but rather than a press enter to continue, the program autocloses.
My main() function (all the used functions are defined, it's not becuase of that) uses iostream library:
#include <iostream>
// all the other functions are defined here
int main()
{
int input1 = getValueFromUser();
int op = getOperationFromUser();
int input2 = getValueFromUser();
int result = getAnswer(input1, op, input2 );
printResult(result);
return 0;
}
Output from Code::Blocks (after main executes, and user has seen their answer)
Process returned 0 (0x0) execution time : 3.930 s
Press any key to continue.
While running normally it simply autocloses, thereby not allowing the user to view their answer!
Thanks in advance!
If you are on Windows, here is a non-portable solution (not recommended):
printResult(result);
system("pause"); //Shows a prompt, "Press any key to continue..."
If you would like to have a portable version (recommended), use
printResult(result);
std::cin.get(); //Waits for input, press enter to continue
You could use std::cin.Ingore();
this way:
http://www.cplusplus.com/reference/istream/istream/ignore/
Your program does not have any command to wait at the end of the execution. That's why it's not waiting. It justs prints the result and return 0, ending the main function immediately.
Add getchar(); before return 0; and then the program will only exit after ENTER is pressed.
Reference: Gangadhar # StackOverflow - "Press Any Key to Continue" function in C. Sep 14, 2013.

C++ read from file

when I try to debug this code to read from a file and display it, the console screen comes and goes quickly and I don't understand why it's doing this. Can anyone help me please?
#include "Questions.h"
#include <iostream>
using namespace std;
const int MAXITEMS = 10;
struct quiz
{
string question;
string anser;
};
int main ()
{
string str;
ifstream ifs("Questions2.txt.txt");
getline (ifs,str);
cout << "first line of the file is " << str << ".\n";
return 1;
}
You should click some breakpoints in VS window.Then when you press F5,it will pause at breakpoint, then it will run continue until you press F5 again.
Or,if you make sure your code is correct.You can press Ctrl+F5.This means "Run Without Debug".
This situation,your program will run to end and suggest you "Press any key to continue".
Sorry for my bad english. Hope you can understand.
try with ifs.open, and then assure yourself by using ifs.is_open () function with an if and an error code, I always use it and it worth
and of course, use a breakpoint before the return (clicking it or using system ("pause")
You can try including a pause function. This way it will display your data and then wait for a response. I've included the function I typically use.
void myPause()
{
cout << " Press enter to continue... ";
char blank[8];
cin.getline(blank,8);
cin.sync();
}
Unless you run with some breakpoints, Visual Studio will close the window after the program terminates.
If you want the window to stay on the screen, use Debug->Start without debugging
Or, add a breakpoint at return 1;
Press F10 instead of F5. By pressing F10, you can go line by line

Running a C++ program with cmd

When I run a program through command line, once the program ends, cmd instantly closes, so I can't see the output easily. Is there anyway to stop this from happening so I can actually verify the output?
#include<iostream>
using namespace std;
class Exercises {
public:
void sayHello(int x) {
for (int i = 0; i < x; i++)
cout << "Hello!!" << endl;
}
}exercise;
int main() {
exercise.sayHello(4);
return 0;
}
You can also use cin.get();
It will wait for you to press enter or until you close the program.
Following methods can help in keeping the command window till another input is provided.
#include <conio.h>
void main(){
// your program here
getch();
}
Another way is to use
system("pause"); at the end of your program.
You can pause the execution of the program for a certain amount of time with:
sleep(5); // sleep for 5 seconds
You could place that at the end of the program before return 0;.
If you don't mind waiting for a keypress at the end of your program, you could put something in.
The simplest way in Windows is to do:
system("pause");
Don't do this if you are releasing your software though. You can implement the behaviour of the pause command easily enough.
std::cout << "Press any key to continue . . . " << std::flush;
while( !_kbhit() ) Sleep(25);
getch();
That's using stuff from conio.h.
However, I'm concerned about the cmd shell itself closing. When you say you "run with cmd", are you actually running up a shell, then typing in your program name and hitting Enter? If that closes the shell, then something is wrong. More likely, you're running it by double-clicking the file in Explorer, right?

very basic C++ program closes after user input for no particular reason?

I just started learning C++ and I wrote this sample program from the text and when I compile and run it, it just closes after the user inputs any number and presses enter. I'm guessing the answer to this is very obvious so forgive me as newbie here....it's really my first C++ program :P
#include <iostream>
using namespace std;
int main ()
{
int numberOfLanguages;
cout << "Hello Reader.\n"
<< "Welcome to C++.\n"
cout << "How many programming languages have you used? ";
cin >> numberOfLanguages;
if(numberOfLanguages < 1)
cout << "Read the preface. You may prefer.\n"
<< "a more elementary book by the same author.\n";
else
cout << "Enjoy the book.\n";
return 0;
}
Imagine you were designing a model for application execution. You have two choices:
A) When the end of a program is reached it shall terminate.
B) When the end of a program is reached the program shall remain alive in some strange limbo state. It will still retain system resources and will not actually be doing anything, but in order to close the user must terminate it explicitly.
I think anyone would go for option A here, and that is what you are seeing. The end of main is reached and your program exits.
If you would like it to pause at the end take some input from the user, i.e.,
char c;
std::cin >> c;
return 0;
The program closes because there's nothing more for the program to do. It outputs the final statements really really fast and then reaches return 0 which causes it to exit. You'll want to do something there to pause the program.
On Windows, a basic way to do that is system("pause"); (you will need #include <stdlib.h>)
cin.getline is a more standard way to do it.
It closes because the execution reaches return 0; and there is nothing left to do.
If you want the program to wait before closing you could add an something like this:
cout << "Press enter to exit...";
cin >> someVarThatWontBeUsed;
You could also run the program from the command line instead of running the .exe. It will reach end of execution anyway but the prompt will stay open.
Your program ends right after you print out your text. If you want to see anything on the screen you can add a cin right before your return 0 so your program waits for a user response before exiting.
// Wait for user to hit enter
cin >> dummyVar;
return 0;
Either put another read from cin to wait for the user, or open the Command Prompt yourself and run it there.
The program you posted has an error. I was not able to compile what you posted.
cout << "Hello Reader.\n"
<< "Welcome to C++.\n"
is not terminated with a semicolon. I added a semicolon and it compiles and runs as you expect.
Edit: Of course, you have to run the program in a terminal that stays open after the program exits, or use cin to wait for more input, or something like that.
After the user inputs a number, which is saved to numberOfLanguages, it reaches return 0 which returns from the main function and thus the program ends.

Is there a decent wait function in C++?

One of the first things I learned in C++ was that
#include <iostream>
int main()
{
std::cout<<"Hello, World!\n";
return 0;
}
would simply appear and disappear extremely quickly without pause. To prevent this, I had to go to notepad, and save
helloworld.exe
pause
ase
helloworld.bat
This got tedious when I needed to create a bunch of small test programs, and eventually I simply put while(true); at the end on most of my test programs, just so I could see the results. Is there a better wait function I can use?
you can require the user to hit enter before closing the program... something like this works.
#include <iostream>
int main()
{
std::cout << "Hello, World\n";
std::cin.ignore();
return 0;
}
The cin reads in user input, and the .ignore() function of cin tells the program to just ignore the input. The program will continue once the user hits enter.
Link
Please note that the code above was tested on Code::Blocks 12.11 and Visual Studio 2012
on Windows 7.
For forcing your programme stop or wait, you have several options :
sleep(unsigned int)
The value has to be a positive integer in millisecond.
That means that if you want your programme wait for 2 seconds, enter 2000.
Here's an example :
#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;
}
If you wait too long, that probably means the parameter is in seconds. So change it to this:
sleep(5);
For those who get error message or problem using sleep try to replace it by _sleep or Sleep especially on Code::Bloks.
And if you still getting problems, try to add of one this library on the beginning of the code.
#include <stdio.h>
#include <time.h>
#include <unistd.h>
#include <dos.h>
#include <windows.h>
system("PAUSE")
A simple "Hello world" programme on windows console application would probably close before you can see anything. That the case where you can use system("Pause").
#include <iostream>
using namespace std;
int main(void)
{
cout << "Hello world!" << endl;
system("PAUSE");
return 0;
}
If you get the message "error: 'system' was not declared in this scope" just add
the following line at the biggining of the code :
#include <cstdlib>
cin.ignore()
The same result can be reached by using cin.ignore() :
#include <iostream>
using namespace std;
int main(void)
{
cout << "Hello world!" << endl;
cin.ignore();
return 0;
}
cin.get()
example :
#include <iostream>
using namespace std;
int main(void)
{
cout << "Hello world!" << endl;
cin.get();
return 0;
}
getch()
Just don't forget to add the library 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;
}
You can have message telling you to use _getch() insted of getch
Lots of people have suggested POSIX sleep, Windows Sleep, Windows system("pause"), C++ cin.get()… there's even a DOS getch() in there, from roughly the late 1920s.
Please don't do any of these.
None of these solutions would pass code review in my team. That means, if you submitted this code for inclusion in our products, your commit would be blocked and you would be told to go and find another solution. (One might argue that things aren't so serious when you're just a hobbyist playing around, but I propose that developing good habits in your pet projects is what will make you a valued professional in a business organisation, and keep you hired.)
Keeping the console window open so you can read the output of your program is not the responsibility of your program! When you add a wait/sleep/block to the end of your program, you are violating the single responsibility principle, creating a massive abstraction leak, and obliterating the re-usability/chainability of your program. It no longer takes input and gives output — it blocks for transient usage reasons. This is very non-good.
Instead, you should configure your environment to keep the prompt open after your program has finished its work. Your Batch script wrapper is a good approach! I can see how it would be annoying to have to keep manually updating, and you can't invoke it from your IDE. You could make the script take the path to the program to execute as a parameter, and configure your IDE to invoke it instead of your program directly.
An interim, quick-start approach would be to change your IDE's run command from cmd.exe <myprogram> or <myprogram>, to cmd.exe /K <myprogram>. The /K switch to cmd.exe makes the prompt stay open after the program at the given path has terminated. This is going to be slightly more annoying than your Batch script solution, because now you have to type exit or click on the red 'X' when you're done reading your program's output, rather than just smacking the space bar.
I assume usage of an IDE, because otherwise you're already invoking from a command prompt, and this would not be a problem in the first place. Furthermore, I assume the use of Windows (based on detail given in the question), but this answer applies to any platform… which is, incidentally, half the point.
The appearance and disappearance of a window for displaying text is a feature of how you are running the program, not of C++.
Run in a persistent command line environment, or include windowing support in your program, or use sleep or wait on input as shown in other answers.
the equivalent to the batch program would be
#include<iostream>
int main()
{
std::cout<<"Hello, World!\n";
std::cin.get();
return 0;
}
The additional line does exactly what PAUSE does, waits for a single character input
There is a C++11 way of doing it. It is quite simple, and I believe it is portable. Of course, as Lightness Races in Orbit pointed out, you should not do this in order to be able to see an Hello World in your terminal, but there exist some good reason to use a wait function. Without further ado,
#include <chrono> // std::chrono::microseconds
#include <thread> // std::this_thread::sleep_for
std::this_thread::sleep_for(std::chrono::microseconds{});
More details are available here. See also sleep_until.
Actually, contrary to the other answers, I believe that OP's solution is the one that is most elegant.
Here's what you gain by using an external .bat wrapper:
The application obviously waits for user input, so it already does what you want.
You don't clutter the code with awkward calls. Who should wait? main()?
You don't need to deal with cross platform issues - see how many people suggested system("pause") here.
Without this, to test your executable in automatic way in black box testing model, you need to simulate the enter keypress (unless you do things mentioned in the footnote).
Perhaps most importantly - should any user want to run your application through terminal (cmd.exe on Windows platform), they don't want to wait, since they'll see the output anyway. With the .bat wrapper technique, they can decide whether to run the .bat (or .sh) wrapper, or run the executable directly.
Focusing on the last two points - with any other technique, I'd expect the program to offer at least --no-wait switch so that I, as the user, can use the application with all sort of operations such as piping the output, chaining it with other programs etc. These are part of normal CLI workflow, and adding waiting at the end when you're already inside a terminal just gets in the way and destroys user experience.
For these reasons, IMO .bat solution is the nicest here.
What you have can be written easier.
Instead of:
#include<iostream>
int main()
{
std::cout<<"Hello, World!\n";
return 0;
}
write
#include<iostream>
int main()
{
std::cout<<"Hello, World!\n";
system("PAUSE");
return 0;
}
The system function executes anything you give it as if it was written in the command prompt. It suspends execution of your program while the command is executing so you can do anything with it, you can even compile programs from your cpp program.
Syntax:
void sleep(unsigned seconds);
sleep() suspends execution for an interval (seconds).
With a call to sleep, the current program is suspended from execution for the number of seconds specified by the argument seconds. The interval is accurate only to the nearest hundredth of a second or to the accuracy of the operating system clock, whichever is less accurate.
This example should make it clear:
#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;
}
Remember you have to #include dos.h
EDIT:
You could also use winAPI.
VOID WINAPI Sleep(
DWORD dwMilliseconds
);
Sleep Function(Windows)
Just a note,the parameter in the function provided by winapi is in milliseconds ,so the sleep line at the code snippet above would look like this "Sleep(2000);"
getchar() provides a simplistic answer (waits for keyboard input).
Call Sleep(milliseconds) to sleep before exit.
Sleep function (MSDN)
You can use sleep() or usleep().
// Wait 5 seconds
sleep( 5 );
Well, this is an old post but I will just contribute to the question -- someone may find it useful later:
adding 'cin.get();' function just before the return of the main() seems to always stop the program from exiting before printing the results: see sample code below:
int main(){
string 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;
}
Before the return statement in you main, insert this code:
system("pause");
This will hold the console until you hit a key.
#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
}
The second thing to learn (one would argue that this should be the first) is the command line interface of your OS and compiler/linker flags and switches.