Digits of a HugeInteger Object Stored in a String Object - c++

Question

I am working on a huge integer problem where I have to create a HugeInteger class where the digits are to be stored in a string object instead of an array of unsigned shorts of a fixed (static) size. I am stuck on how to implement this. When I run the program, I input values for my HugeInteger objects but then nothing gets displayed afterwards. Would appreciate some help. Thanks in advance.
Below is my source code of what I have so far.
HugeInteger.h
#include <iostream>
#include <array>
#include <string>
class HugeInteger
{
// need to offer friendship to these 2 functions
friend std::istream & operator >> (std::istream & src, HugeInteger & value);
friend std::ostream & operator << (std::ostream & dest, const HugeInteger & value);
public:
//ctor that converts a "long long" into a HugeInteger
HugeInteger(long long value = 0LL); //0LL is constant literal value 0
// of type long long
//ctor that converts a string into a HugeInteger
HugeInteger( char *str);
//Convert a string into a HugeInteger
void input( char *str);
private:
bool negative; // will be true if number is negative
std::string hugeInt; // each digit is stored in a string object
};
//overloads the << and >> operators for the HugeInteger class
std::istream & operator >> (std::istream & src, HugeInteger & value);
std::ostream & operator << (std::ostream & dest, const HugeInteger & value);
HugeInteger.cpp
#include "HugeInteger.h"
#include <iostream>
using namespace std;
// ctor converts a long long into a HugeInteger
HugeInteger::HugeInteger(long long value)
{
// set all MaxDigit digits to zero to start
this->negative = false;
if (value < 0LL){ // 0LL is constant literal 0 of type long long
this->negative = true;
value = -value; // make the value positive
}
unsigned int i = 0;
for (; i < hugeInt.size(); i++)
{
this->hugeInt[i] = '0';
}
this->hugeInt[i] = '\0';
// convert individual digits of input value into a HugeInteger
for (unsigned int j = hugeInt.size() - 1; j >= 0 && value != 0LL; j--)
{
short result = value % 10;
char c = (char)result;
this->hugeInt[j] = c;
value /= 10;
}
// test to make sure that HugeInteger was able to contain value
if (value != 0LL){
*this = 0LL; // set to -0, to signal overflow
this->negative = true; // Possibly should increase value assigned
} // to MaxDigit to fix this problem.
}
// converts string into a HugeInteger object
HugeInteger::HugeInteger(char *str)
{
this->input(str); //See HugeInteger::input() method below
}
void HugeInteger::input( char *str)
{
// assume positive for now
this->negative = false;
// init. to all zeros first
unsigned int i = 0;
cin.getline(str, sizeof str);
cin.sync();
cin.clear();
while (i < strlen(str) - 1)
{
if (isdigit(str[i]))
{
this->hugeInt[i] = str[i];
i++;
}
}
istream & operator>>(istream & input, HugeInteger & value)
{
char inputString[1002];
input >> inputString;
value.input(inputString);
return input;
}
ostream & operator << (ostream & output, const HugeInteger & value)
{
// find first non-zero digit
unsigned int i = 0;
while (i < value.hugeInt.size()){
if (value.hugeInt[i] != '0'){
break;
}
++i;
}
// if all zeros, just output a single 0
if (i == 40)
{
cout << '0';
return output;
}
// check if we need to ouput a negative sign
if (value.negative){
cout << '-';
}
// output remaining digits
for (; i < value.hugeInt.size(); i++)
{
cout << value.hugeInt[i];
}
return output;
}
MainProg.cpp
#include "HugeInteger.h" // include definiton of class HugeInteger
using namespace std;
int main()
{
HugeInteger A, B, C, D;
// input value for A & B
cout << "****** Test << & >> operators ******\n\n";
cout << "Input values for A and B: ";
cin >> A >> B;
cout << "\nA = " << A << "\nB = " << B;
system("pause");
return 0;
} // end main

Answer 1

There are several issues with your code, however the most glaring are your input functions.
First, why does HugeInteger::input need to know how the input was retrieved? There is no need for cin or any I/O -- it's job is to solely take a char * pointer, and loop through it creating the hugeInt string.
Therefore, the lines below should be removed:
cin.getline(str, sizeof str);
cin.sync();
cin.clear();
The next issue is the actual loop. There are several things wrong with it.
First, you should be incrementing i, regardless if the character is a digit or not. Otherwise, you will end up in an infinite loop if the character is not a digit.
Second, when you are building the hugeInt string, you should be concatentating the character onto the string. Your current code leads to undefined behavior since you are accessing hugeInt[i], and hugeInt is an empty string, so there is no i entry.
So the changes there would be this:
while (i < strlen(str) - 1)
{
if (isdigit(str[i]))
this->hugeInt += str[i];
i++;
}
Now, a better implementation would be to have input take a std::string, not a char*. Now, the total function would be rewritten thusly:
void HugeInteger::input(const std::string& str)
{
// assume positive for now
this->negative = false;
// init. to all zeros first
unsigned int i = 0;
this->hugeInt.clear();
while (i < str.size())
{
if (isdigit(str[i]))
this->hugeInt += str[i];
i++;
}
}
The last issue is your operator >>. There is no need to limit yourself to 1002 characters. Just input into a std::string.
istream & operator>>(istream & input, HugeInteger & value)
{
string inputString;
input >> inputString;
value.input(inputString);
return input;
}
After these changes, the sample runs correctly: http://ideone.com/F47TEV
Edit:
An alternate way of extracting the digits and appending onto a string using the STL algorithm functions would be as follows:
void HugeInteger::input(std::string str)
{
// assume positive for now
this->negative = false;
str.erase(std::remove_if(str.begin(), str.end(), [](char ch)
{ return !isdigit(ch);}), str.end());
hugeInt = str;
}
The std::remove_if is stable, so the relative order of the digits will not be changed. Also note that we pass by value, as this gives the compiler (if it's C++ 11) a good chance to optimize the copy that is passed (as opposed to making your own copy inside the function).

Answer 2

Your current code leads to undefined behavior since you are accessing hugeInt[i], and hugeInt is an empty string, so there is no i entry.
Just to add to this, the lines
for (; i < hugeInt.size(); i++)
and
for (unsigned int j = hugeInt.size() - 1; j >= 0 && value != 0LL; j--)
will never initially execute as hugeInt.size() will be 0 and the for loop condition will never be satisfied