Own Big Float in C++

Question

I want to write my own variable "type" as a homework in C++. It should be an arbitrarily long float. I was thinking of structure like...

Code:

class bigFloat
{
public:
    bigFloat(arguments);
    ~bigFloat();

private:
    std::vector<char> before; // numbers before decimal point
    std::vector<char> after; // numbers after decimal point
    int pos; // position of decimal point
};

Where if i have number like: 3.1415 Before = '3'; after = '1415'; pos = 1; If that makes sense to you... BUT assignment wants me to save some memory, which I don't because for every number I allocate about it is about 1 byte, which is too much I guess.

Question:

How would you represent those arbitrarily long numbers? (Sorry for my bad english, I hope the post makes sense)

Answer 1

If you need to preserve memory, all that means is that you need to use memory as efficiently as possible. In other words, given the value you're storing, you shouldn't waste bytes.

Example:

1. 255 doesn't need 32 bits

I think your vector of chars is fine. If you're allowed to use a C++11 compiler, I'd probably change that to a vector of uint8_t and make sure when I'm storing the value that I can store a value from 0 to 255 in a vector of size 1.

However, that's not the end of it. From the sounds of it, what you're after is an arbitrary number of significant digits. However, for a true float representation, you also need to allocate storage for the base and exponent, after deciding what the base will be for your type. There is also the question of whether you want your exponent to be arbitrarily long too. Let's assume so.

So, I'd probably use something like this for members of your class:

//Assuming a base of 10.
static uint8_t const base = 10;
std::vector<uint8_t> digits_before_decimal;
std::vector<uint8_t> digits_after_decimal;
std::vector<uint8_t> exponent;
std::bitset<1> sign;

It is then a matter of implementing the various operators for your type and testing various scenarios to make sure your solution works.

If you really want to be thorough, you could use a simple testing framework to make sure that problems you fix along the way, stay fixed.

In memory, it will essentially look like a binary representation of the number.

For example:
65535 will be: before_decimal =<0xff,0xff>, after_decimal vector is empty
255.255 will be: before_decimal =<0xff>, after_decimal=<0xff>
255255 will be: before_decimal =<0x03,0xe5,0x17>, after_decimal vector is empty
255255.0 will be: before_decimal =<0x03,0xe5,0x17>, after_decimal: <0>

As others have mentioned, you don't really need two vectors for before and after the decimal. However, I'm using two in my answer because it makes it easier to understand and you don't have to keep track of the decimal. The memory requirements of two vs one vector really aren't that different when you're dealing with a long string of digits.

I should also note that using an integer to record position of the decimal point limits your number of digits to 2 billion, which is not an arbitrarily long number.

UPDATE: If this actually is homework, I would check with whoever has given you the homework if you need to support any floating point special cases, the simplest of which would be NaNs. There are other special cases too, but trying to implement all of them will very quickly turn this from a homework assignment into a thesis. Good luck :)