[X] My Assistant

[bad_karma00]

I'm just a beginner but we've been taught to use the following:

CODE

#include<iostream>
#include<iomanip>
#include<cmath>
using namespace std;

int main()
{
    int stop;
    
    
    
    
    
    cin >> stop;
    return 0;
}

[Cerolobo]

The below code will "pause" the console. Plus, it's ANSI C, so it'll work in C/C++

CODE

#include <stdio.h>

int main(void)
{
  printf("Hit \"Enter\" to continue\n");
  fflush(stdin); /* Remove anything that is currently in the standard input */
  getchar();     /* Wait for the user to hit the enter key */
  fflush(stdin); /* Remove any additional charcters the user may have inputed */

  return 0;
}

Of course, this is a lot more useful as a macro

CODE

#include <stdio.h>

#define PAUSE {printf("Hit \"Enter\" to continue\n");fflush(stdin);getchar();fflush(stdin);}

int main(void)
{
  PAUSE

  return 0;
}

PAUSE contains it's own scope, so it will not produce adverse effects. IE, this will work

CODE

if(foo)
  PAUSE;

Now, I personally don't like to have to key a extra key to quit, but I love the macro for debugging, as long as you remove the printf(). For example, useing a non recursive string reversal.

CODE

#include <stdio.h>  /* fflush(), getchar(), printf(), stdin */
#include <string.h> /* strlen() */

#define PAUSE {fflush(stdin);getchar();fflush(stdin);}

void ReverseString(char *str);

int main(int argc, char *argv[])
{
  if(argc != 2)
  {
    printf("Usage: %s \"TEXT\"\n", argv[0]);
    return 0;
  }

  ReverseString(argv[1]);

  printf("%s\n", argv[1]);

  return 0;
}

void ReverseString(char *str)
{
  int len = strlen(str) - 1;
  int i;
  char c;

  for(i = 0; i < len; ++i, --len)
  {
     c        = str[i];
     str[i]   = str[len];
     str[len] = c;

/* Note: These are offset to the left to make it apparent they are debug data */
{
int j;
printf("%s\n", str);
for(j = 0; j < i; ++j)
  putchar(' ');
putchar('^');
for(; j < len - 1; ++j)
  putchar(' ');
putchar('^');
PAUSE;
putchar('\n');
}
  }
}

Edit: Forgot a fflush(stdin);

This post has been edited by Cerolobo: 9 Apr, 2008 - 03:47 AM

[mikeblas]

I think my point may have been missed. I advise against the use of getch(). It is a platform dependent function that does not comply to ANSI standards. It is not part of standard C++.

Are developers who don't know simple things, like how to stop the debugger from closing the console window after execution has stopped, really interested in porting code to multiple platforms?

Better than any of these recommendations, in my opinion, is to learn how to use the debugger. If someone wants to view the output before the application closes, then they should place a breakpoint in the code before the application closes. Debugging is an important skill. You can't start too early!

[gabehabe]

I learned to create a batch file using notepad (when using windows OS)

if the name of my program was "Game_Over" i would type

CODE

Game_Over.exe
pause

and i would just execute the batch file. but the only problem is that the name of the exe. file has to be one word.

Quoting a really old post here, but just thought I'd have a little input

The file doesn't have to be one word, you could do something like this:

CODE

"game over.exe"
pause

[Amadeus]

I think my point may have been missed. I advise against the use of getch(). It is a platform dependent function that does not comply to ANSI standards. It is not part of standard C++.

Are developers who don't know simple things, like how to stop the debugger from closing the console window after execution has stopped, really interested in porting code to multiple platforms?

Better than any of these recommendations, in my opinion, is to learn how to use the debugger. If someone wants to view the output before the application closes, then they should place a breakpoint in the code before the application closes. Debugging is an important skill. You can't start too early!

An excellent point...but I fully expect that well over 95% of the users of this board not to use a debugger. Further, i usually try to endorse proper debugging through the use of old school debugging techniques - the manual insertion of specific breakpoints in the code.

If you review many of the topics on the board that ask about holding the execution window open, most are not trying to track bugs...they are only trying to see the end result, but have only ever learned how to program using an IDE and do not understand how that IDE works. Despite the fact that I have grave reservations about programmers who ONLY know how to use an IDE, I try to at least provide them with some basic understanding of that IDE's functionality.

Frankly, if I had the time to explain how to use the debugger (or debug mode) of whatever IDE/compiler they are using, I'd point them towards the documentation for that specific IDE/complier and use the time to have a beer.

[gabehabe]

So many people use system("pause"); in Windows console apps...

DON'T!

here's why...

[CalumJR]

I have a question please.

Our tutors at university have always said to use

CODE

while(!_kbhit());

in order to hold the screen for input. This is in the conio.h library & it works perfectly in Visual Studio 2005.

What I'd like to know is why hasn't this really been mentioned much & why doesn't it seem to be used commonly?

Also, what would be the best code to use, which does the same function as kbhit, which is cross-platform & cross-compiler?

Thanks in advance.
cJr.

This post has been edited by cJr.: 6 Aug, 2008 - 10:25 AM

[gabehabe]

I'll be honest with you, I've never actually seen that before.

However, I would still advise against the use of it, since conio.h does not conform to all standards, and it isn't going to be around forever. I always see a lot of people using conio.h in their programs~ granted, it has some very useful functions, but it's best to stick to the standards.

Personally, I tend to use cin.get (); (in C++ anyway)
Granted, it waits for the user to press enter, but we could just prompt them:

cpp

#include <iostream>

void pause ()
{
    std::cout << "\nPress the enter key to continue . . .";
    std::cin.get ();
}

int main ()
{
    pause();
    return EXIT_SUCCESS;
}

[CalumJR]

Thank you gabehabe. I knew the way I'm being taught wasn't the best one to use after seeing this thread, but I just didn't know why.

You've cleared it up for me now, thank you.

I will try & use:

CODE

cin.get();

in future & see how I get along

[gabehabe]

Confront your university teachers about it, ask them why they use it.

I personally don't think it's too good an idea, I'm just intrigued as to why a higher-level education would suggest using something like that.

[CalumJR]

Thank you for the idea. I will ask them, especially when now I've just changed all the code in this big program I am making to "cin.get();" instead of "while(!_kbhit());" and it works perfectly! lol.

[KYA]

Weird, I have never seen kbhit either...

[gabehabe]

@cJr:
Did you ask your teachers why they suggested that?

[KYA]

[gabehabe]

That was his first post.

Was that supposed to offend us?

[KYA]

I guess...?

[gabehabe]

Hey, android 16, was you aiming to insult us?

[KYA]

We don't take kindly to fellows....


I'm looking for the guy who shot my Pa.

[CalumJR]

@cJr:
Did you ask your teachers why they suggested that?

No, I haven't been able to yet as I haven't been back to uni. I start again in late September. But I will try & email one of them if f I can.

[RedSonja]

Cheap and nasty way I use every day to start exe files and see what they are doing (I do a lot of old code).


Make a little text file, call it run.bat. Put this in it:

MyStuff.exe
pause



double click it, a DOS window opens, your exe writes its stuff in there and won't go away till you tell it to.