Hello World!

[Chillieman]

Hello everyone! I have a little bit of a problem, It shouldn't be a problem for anyone. On that note, this post is basically just to say hi to everyone! I decided to join this community, because its always nice to have people who can annoy people who can answer my newbie questions.

I didn't think it was right to put a post just saying hi, So I will be including a problem!

When i write this little snippet of code

...
int iSomething;
for(;;)
{
   cin >> iSomething;
   if(iSomething == 0)
   {
   cout << "Zeros are ignored, Input a Positive number" <<endl;
   continue;
   }
...
...
}}

When i have this in my program, i realize one thing. If a user inputs any charaters (Or a number outside the limits of int), then iSomething seems to get overloaded, and gets stuck with a value of 0, creating an endless loop.

I thought of a way to get out of the constant loop that occurs, by calling a function

bool ExitCheck ()
{
   static int nExitCount = 0;
   nExitCount++;
   if(nExitCount == 100)
   {
   return true; //tells the program to Exit and return 1
   }
   else
   {
   return false; //Tells the for loop to continue
   }
}
...
...
...

int iSomething;
bool Exit;
for(;;)
{
   cin >> iSomething;
   if(iSomething == 0)
   {
      cout << "Zeros are ignored, Input a Positive number" <<endl;
      Exit = ExitCheck();
      if(!Exit)
      {
      continue;
      }
      else
      {
      return 1;
      }
   }
...
...
}}

This would prevent the program from terminating if the user actually inputted the number zero(unless they did it a hundred times) Yet it would shut the program down if the the loop was causing a zero over and over again.

My question is (finally) how would i go about making my exit code obsolete? If some one enters a character for my nSomething, i would want to be able to erase that value, and allow them to give it another attempt.

I was looking around at the other posts, just to take a peek at other peoples programming, and i saw the mentioning of a "cin.ignore()" and i am wondering if that's where the answer lies

Well, i would like some feedback. I don't care if its just to say "Hello, welcome to the community" or if it's to say "Your programming style sucks!" or if its the answer to my question! Like i said, im just posting this to say hi to the community.

So to Sum up my post in a couple of words:

Hello World! ^{^_^}

[JLBorges]

> i saw the mentioning of a "cin.ignore()" and i am wondering if that's where the answer lies

Yes. In conjunction with std::cin.clear() ;

#include <iostream>

int read_int( int min, int max )
{
    int value ;
    std::cout << "enter an integer in the range [" << min << '-' << max << "]: " ;
    if( std::cin >> value && value >= min && value <= max ) return value ;
    else
    {
        std::cout << "error in input.\n" ; // inform the user
        std::cin.clear() ; // clear the error
        std::cin.ignore( 1024, '\n' ) ; // throw away the junk (upto 1024 characters)
        return read_int( min, max ) ; // and try again
    }
}

[andywestken]

Though it is better done without recursion.

Andy

int read_int( int min, int max )
{
    for( ; ; ) // loop forever
    {
        std::cout << "enter an integer in the range [" << min << '-' << max << "]: " ;
        int value = 0;
        if( std::cin >> value && value >= min && value <= max )
            return value ;
        std::cout << "error in input.\n" ; // inform the user
        std::cin.clear() ; // clear the error
        std::cin.ignore( 1024, '\n' ) ; // throw away the junk (up to 1024 characters)
    }
}

[JLBorges]

> Though it is better done without recursion.

You need to educate yourself on recursion.

[andywestken]

Given the two solutions are next to identical, except for the loop versus recursive call, I would go for the iterative solution as it avoids the unnecessary, extra stack pushing and popping.

I follow the school of thought that believes that recursion should only be used when the degree of simplification justifies the call overhead (however small it is.)

Andy

[JLBorges]

> Given the two solutions are next to identical, except for the loop versus recursive call,
> I would go for the iterative solution as it avoids the unnecessary, extra stack pushing and popping.
> ... recursion should only be used when the degree of simplification justifies the call overhead

Repeat: You need to educate yourself on recursion.

Tip: the simpler the function involving the tail call, the easier it is for the optimizer to perform TCO.

int cstr_to_int_iterative( const char* digits )
{
    int number = 0 ;
    for( int i = 0 ; digits[i] != 0 ; ++i )
        number = number * 10 + digits[i] - '0' ;
    return number ;

    /*
    // GCC 4.8 i686 with -O3 -fomit-frame-pointer

    __Z21cstr_to_int_iterativePKc:
    LFB0:
        movl	4(%esp), %ecx
        movsbl	(%ecx), %edx
        testb	%dl, %dl
        je	L4
        addl	$1, %ecx
        xorl	%eax, %eax
    L3:
        addl	$1, %ecx
        leal	(%eax,%eax,4), %eax
        leal	-48(%edx,%eax,2), %eax
        movsbl	-1(%ecx), %edx
        testb	%dl, %dl
        jne	L3
        rep ret
    L4:
        xorl	%eax, %eax
        ret
    */
}

int cstr_to_int_recursive( const char* digits, int number = 0 )
{
   if( digits[0] == 0 ) return number ;
   return cstr_to_int_recursive( digits+1, number*10 + digits[0] - '0' ) ;

    /*
    // GCC 4.8 i686 with -O3 -fomit-frame-pointer

    __Z21cstr_to_int_recursivePKci:
    LFB1:
        movl	4(%esp), %ecx
        movl	8(%esp), %eax
        movsbl	(%ecx), %edx
        testb	%dl, %dl
        je	L10
    L11:
        addl	$1, %ecx
        leal	(%eax,%eax,4), %eax
        leal	-48(%edx,%eax,2), %eax
        movsbl	(%ecx), %edx
        testb	%dl, %dl
        jne	L11
    L10:
        rep ret
    */
}

[andywestken]

I am aware of tail recursion.

To clarify: are you saying that your original iterative function, read_int(), will also be tail-call optimized?

Andy

[Chillieman]

Thank you for answering my newbie question! =D

lulz, I love nerd battles, but jeez guys:

This is all I was looking for:

std::cin.clear() ; // clear the error
std::cin.ignore( 1024, '\n' ) ; // throw away the junk (upto 1024 characters) 

Another question I had about std::cin.ignore()
I figured out if I put cin.ignore() directly on top of an input line:

std::cin.ignore(2, '\n')
std::cin >> iSomething

When I press enter with 10-99 (2 charcters), nothing happens, so it gets ignored, just creates a new line on the command prompt.

What if I wanted to instruct the program to ignore ANYTHING over 9
so in human terms:
Tell the following "std::cin >>iSomething" to ignore the input if the user inputs anything larger then 1 character

[giblit]

you could just do something like

int input;
while( !std::cin >> input || input > 9 )
{
    std::cin.clear();
    std::cin.ignore( 1024 , '\n' ); //You can also use numeric_limits.
}

Edit..pretty much this function says while you cannot input a number or it is greater than 9 you clear the input stream and then ignore everything then get a new input and check if it is greater than 9. If it is not greater than 9 then you move on keeping that number.


EDIT:: looks like jl and andre already answered this earlier chillie =p

EDIT:::if you use numeric_limits its like this

#include <climits>
std::numeric_limits<std::streamsize>::max(); //for stream max anyways which you would use for ingore 

[JLBorges]

> "std::cin >>iSomething" to ignore the input if the user inputs anything larger then 1 character

char c ; std::cin >> c ; // read one non-whitespace character

std::string str ;

// read upto a maximum of five characters after skipping leading white space
std::cin >> std::setw(5) >> str ;

// throw away everything after that upto and including a new line
std::cin.ignore( std::numeric_limits<std::streamsize>::max(), '\n' ) ;

> are you saying that your original iterative function, read_int(), will also be tail-call optimized?

When I mentioned TCO, I was responding to: "recursion should only be used when the degree of simplification justifies the call overhead (however small it is.)"

Re: avoiding "the unnecessary, extra stack pushing and popping" in this particular function? At the end of an iteration in which there were more than half a dozen calls to non-trivial library functions? Which involved blocking to read and parse an integer typed in by the user?

I find that concern laughable.

[Chillieman]

Lol, giblet your right, they did already answer the question in the aspects of creating a separate rule dealing with numbers, but I was more then less referring to what JL stated

// read upto a maximum of five characters after skipping leading white space
std::cin >> std::setw(5) >> str ;

This will allow me to block out anything more then 1 character (whether it be 0-9 or a-z)


As for this:

std::numeric_limits<std::streamsize>::max(); 
//for stream max anyways which you would use for ingore 

I really like this aswell because I get errors if the user enters a number higher then int's limits. So now I should be able avoid that

Thank you everyone =]

[NyhkoG1T]

i encountered this issue the other day, where I inputted a letter and an infinite loop occured. This is how I fixed it.

			if(!cin) {
				cout << endl << "You entered an ERRONEOUS value. Please try again." << endl;
				cin.clear();
				cin.ignore();
				continue; //test code is inside infinite loop
			}

Whenever you enter something the isn't correct, like a letter for an integer value, cin set's a failbit. You can check that failbit by using either if(!cin) or if(cin.fail())

The above code worked flawlessly but if anyone knows of any reason not to use this, please enlighten me.

[giblit]

Try putting in a number greater than 9. look at the code I posted. It checks if it fails or if the number is greater than 9 if so then it repeats.

[Chillieman]

Very good Lucian, but giblet already gave that answer with this snippit

while( !cin >>input || input > 9 )
{
    cin.clear();
    cin.ignore( 1024 , '\n' );
}

My new, current question:

What do I have to #include to grant myself the use of

int iSomething;
cin>>setw(1)>>iSomething;

My apologies if this is unnecessary, I know I could just use

int iSomething;
cin>>iSomething;
if(iSomething > 9) {}

Just realized this is completely not what I am trying to accomplish. because if some one typed in "12" then it would read as "1" instead of ignoring the "12" altogether.

Still, I would like to know what I need to #include to gain access to setw() when im dealing with strings


I like to teach my self ALL the ways to skin a cat

[giblit]

#include <iomanip>
http://www.cplusplus.com/reference/iomanip/

Also my method shouldn't read in 12 because 12 is greater than 9 and I meant || not && earlier because we want it to get a new number if it is less than 9 or it is a letter( fails to input. ) and not get a new number only if both of those are true.

[Chillieman]

Thank you giblet, You have been very helpful ^_^ I completely understand what your saying.

That will be the end to my questions for today