#include <iostream>
#include <sstream>
#include <string>
 
int main()
{
  std::string line;
 
  std::cout<<"Enter a number: ";
 
  if ( getline ( std::cin, line ) ) {
    std::stringstream conv ( line );
    int result;
 
    if ( conv>> result )
      std::cout<< result <<" squared is "<< result * result <<'\n';
    else
      std::cerr<<"Invalid input\n";
  }
}

#include <ctype.h>
#include <errno.h>
#include <limits.h>
 
const char *parse_int ( const char *s, int *value )
{
  /* Base of the final converted value */
  const unsigned base = 10;
 
  /* Largest value that won't ever overflow */
  const unsigned limit = UINT_MAX / base;
 
  /* Largest value that won't overflow beyond the limit */
  const unsigned top_digit = UINT_MAX % base;
 
  unsigned overflow = 0; /* True if integer overflow occurs */
  unsigned sign = 0;     /* Final sign of the converted value */
 
  unsigned temp = 0;     /* Intermediate converted value */
  unsigned n = 0;        /* Count of converted digits */
 
  /* Save and skip over the sign if present */
  if ( *s == '-' || *s == '+' )
    sign = *s++ == '-';
 
  /* Build the intermediate value */
  for ( ; isdigit ( *s ); s++, n++ ) {
    unsigned digit = *s - '0';
 
    /*
      This protects *only* the intermediate value
      from overflow. Overflow of the final value
      requires further checks
    */
    overflow =  temp > limit
      || ( temp == limit && digit > top_digit );
 
    if ( overflow )
      break;
 
    /* Shift-add by the base */
    temp = temp * base + digit;
  }
 
  if ( n > 0 ) {
    /*
      A conversion was made, so now we need to
      deal with overflow and set the final value
    */
    if ( overflow
      || ( sign && temp > -INT_MIN )
      || ( !sign && temp > INT_MAX ) )
    {
      /*
        The intermediate actually overflowed,
        or converting it to int would overflow.
        Either way it's an error to the caller
      */
      errno = ERANGE;
      temp = sign ? -INT_MIN : INT_MAX;
    }
 
    *value = sign ? -(int)temp : (int)temp;
  }
  else if ( sign ) {
    /*
      We found a sign and skipped over it. But
      because no conversion was made, we need
      to "unskip" the sign
    */
    --s;
  }
 
  return s;
}