Reading numbers with getChar() in C++ - c++

Question

I'd like to make a function reading integers from stdin in the fastest way possible. To be more specific I've got a very long sequence of ints separated with spaces finished with EOF on which I've got to make some operations. I used cin but since this function is quite robust in its possibilites I'd like to make something smaller, more specific, and thus, faster and more efficient. I've read that the fastes way of reading stdin is getChar() function. I've already found some implementations of this problem in C, but chars there are just another form of integers and in C++ they're not. My idea is to make a function of type bool
bool myIntRead( int *num);
which would basically read chars of an integer until a 'space sign' and somehow put these chars back into an int number. The bool type would be used to inform that the stdin is empty.
int main() {
int num;
while (myIntRead(&num) ) {
myIntRead(&num)
//some operations on num
}
}
I'm fully aware that this sort of dealing with input is much more complex and more difficult but I'd really like to find out a solution to this problem. I will really appreaciate some help from You Guys in finding out an implementation of this concept.
Best regards!

Answer 1

If you only want to deal with ASCII input and you're sure that input will be provided to you in the expected format (ie. digits 0-9 followed b space) then all you have to do is read each character and then:
Determine if it's a space or a digit
If it's a space, start reading a new number
If it's a digit append digit to current number
The following illustrates that. But it doesn't handle any overflow and there is no stop condition..
int c;
int current_number;
std::vector<int> numbers;
do {
c = getchar();
if(c == 0x20) // it's a space
{
numbers.push_back(current_number); // add the current number to the list of numbers
current_number = 0; // reset the current_number variable back to 0
}else if(c >= 0x30 && c <= 0x39) // it's a digit
{
current_number = current_number * 10 + (c - 0x30); // add next digit..
// you may want to deal with overflow here (ie. if number of digits > MAX_DIGITS or similar)
}
} while (TRUE); // there should be a stop condition here..

Answer 2

the following code reads 1000000 (one million) numbers in 61ms (normal PC some years old). The file has the size of 3.8MB.
#include <iostream>
#include <fstream>
#include <iterator>
#include <vector>
template< typename T, typename Out >
struct IntReader_type
{
IntReader_type( Out out ) : out_( out ) {}
template< typename E, typename Traits >
friend std::basic_istream< E, Traits >& operator>>( std::basic_istream< E, Traits >& in, IntReader_type rdr )
{
std::basic_istream< E, Traits >::sentry ok( in );
if( ok )
{
std::ios_base::iostate state = std::ios_base::goodbit;
try
{
const std::ctype< E >& ct = std::use_facet< std::ctype< E > >( in.getloc() );
while( state == std::ios_base::goodbit )
{
T result = T(0);
for( Traits::int_type m = in.rdbuf()->sgetc(); ; m = in.rdbuf()->snextc() )
{
if( Traits::eq_int_type( m, Traits::eof() ) )
{
state |= std::ios_base::eofbit; // EOF is not an error
break;
}
const E c = Traits::to_char_type( m );
if( ct.is( std::ctype_base::space, c ) )
break;
if( ct.is( std::ctype_base::digit, c ) )
{
(result *= 10) += T(c - E('0'));
}
else
{
state |= std::ios_base::failbit; // not a digit
break;
}
}
*(rdr.out_)++ = result; // store the number
// skip white space character
for( Traits::int_type m = in.rdbuf()->sgetc(); ; m = in.rdbuf()->snextc() )
{
if( Traits::eq_int_type( m, Traits::eof() ) )
{
state |= std::ios_base::eofbit;
break;
}
if( !ct.is( std::ctype_base::space, Traits::to_char_type( m ) ) )
break;
}
}
}
catch( ... )
{
state |= std::ios_base::badbit;
if( in.exceptions() & std::ios_base::badbit )
throw;
}
in.setstate( state );
}
return in;
}
private:
Out out_;
};
template< typename T, typename Out >
IntReader_type< T, Out > read_ints( Out out )
{
return IntReader_type< T, Out >( out );
}
call the Integer-reader in this way:
vector< int > numbers;
if( cin >> read_ints< int >( back_inserter(numbers) ) )
{ // read is done without error
be careful - in this version only unsigned numbers can be read and there is no check of integer overflow.

Answer 3

ok, so c = getchar();
You have to store in in an array for it to be processable.
If c contains one digit, multiply c[0] * 1.
If c contains two digits, multiply c[1] * 1 + c[0] * 10.
If c contains three digits, multiply c[2] * 1 + c[1] * 10 + c[0] * 100.
If c contains four digits, multiply c[3] * 1 + c[2] * 10 + c[1] * 100 + c[0] * 1000, etc etc.
The code for input looks like this:
while(digitInput!=13)
{
if (kbhit())
{
digitInput=getch();
if (digitInput==27) exit(0);
if ((digitInput>47) && (digitInput<59))
{
digitArray[digit]=(unsigned char)digitInput-48;
digit++;
printf("%d",digitInput-48);
}
if (digitInput==13) { digitn=digitArray[0]; break; }
}
}
switch(digit)
{
case 0:
case 1:
digitn=digitArray[0]*1 ;
break;
case 2:
digitn= digitArray[1]*1 +digitArray[0]*10 ;
break;
case 3:
digitn= digitArray[2]*1+digitArray[1]*10 +digitArray[0]*100 ;
break;
case 4:
digitn=digitArray[3]*1+digitArray[2]*10+digitArray[1]*100+digitArray[0]*1000 ;
break;
}
The complete app in code.
#include <iostream.h>
#include <conio.h>
#include <stdio.h>
#include <stdlib.h>
int digit=0,digitInput=0;
int digitArray[10]={0},digitn;
int numberOfInputDigits=4;
/*********************************
* *
********************************/
void getIntKey(void)
{
digitArray[0]=0;
digitArray[1]=0;
digit=0;
digitInput=0;
while(digitInput!=13)
{
if (kbhit())
{
digitInput=getch();
if (digitInput==27) exit(0);
if ((digitInput>47) && (digitInput<59))
{
digitArray[digit]=(unsigned char)digitInput-48;
digit++;
printf("%d",digitInput-48);
}
if (digitInput==13) { digitn=digitArray[0]; break; }
}
}
switch(digit)
{
case 0:
case 1:
digitn=digitArray[0]*1 ;
break;
case 2:
digitn= digitArray[1]*1 +digitArray[0]*10 ;
break;
case 3:
digitn= digitArray[2]*1+digitArray[1]*10 +digitArray[0]*100 ;
break;
case 4:
digitn=digitArray[3]*1+digitArray[2]*10+digitArray[1]*100+digitArray[0]*1000 ;
break;
case 5:
digitn=digitArray[4]*1+digitArray[3]*10+digitArray[2]*100+digitArray[1]*1000+digitArray[0]*10000 ;
break;
case 6:
digitn=digitArray[5]*1+digitArray[4]*10+digitArray[3]*100+digitArray[2]*1000+digitArray[1]*10000
+digitArray[0]*100000;
break;
case 7:
digitn=digitArray[6]*1+digitArray[5]*10+digitArray[4]*100+digitArray[3]*1000+digitArray[2]*10000
+digitArray[1]*100000 +digitArray[0]*1000000;
break;
case 8:
digitn=digitArray[7]*1+digitArray[6]*10+digitArray[5]*100+digitArray[4]*1000+digitArray[3]*10000
+digitArray[2]*100000 +digitArray[1]*1000000+digitArray[0]*10000000;
break;
case 9:
digitn=digitArray[8]*1+digitArray[7]*10+digitArray[6]*100+digitArray[5]*1000+digitArray[4]*10000
+digitArray[3]*100000 +digitArray[2]*1000000+digitArray[1]*10000000 +digitArray[0]*100000000;
break;
}
// if (digitInput!=13) digitn=digitArray[3]*1+digitArray[2]*10+digitArray[1]*100+digitArray[0]*1000 ;
printf("\n%i\n\n",digitn);
}
/*********************************
* *
********************************/
int main()
{
system("color 1F"); //Blue background
printf("Digits Into decimal numbers \n ");
printf("Max Input is %d Digits \n ",numberOfInputDigits);
printf("\nInput Digit >");
getIntKey();
printf("\nThe input was digitArray[7]=%d \n",digitArray[7]);
printf("digitArray[6]=%d \n",digitArray[6]);
printf("digitArray[5]=%d \n",digitArray[5]);
printf("digitArray[4]=%d \n",digitArray[4]);
printf("digitArray[3]=%d \n",digitArray[3]);
printf("digitArray[2]=%d \n",digitArray[2]);
printf("digitArray[1]=%d \n",digitArray[1]);
printf("digitArray[0]=%d \n",digitArray[0]);
printf("\n%i\n\n",digitn);
return 0;
}