factorial with bignum class

[wtf]

I have the basics down on my integer class. (addition and multiplication, subtraction and division I'm putting on hold until i get everything else right.)

the thing is i can only compute up to 8! before it begins to crash.
Sometomes it gets 8! correct, other times it crashes,
still others it gets it totally wrong like:

8! = 403225306

or

8! = 4032-14423

I don't understand what is going on. Coule someone please help me? All I wanted to do was take a short break and write a simple bignum class and this is driving me crazy.

#include "integer.h"
#include <stdexcept>

using namespace std;

runtime_error Negative_Factorial("Negative factorial not supported");

bool clearbuf()
    {char ioch; do ;  while( (ioch = getchar() != '\n' ) ); return true;}

integer factorial(integer x);
//very big factorial(very big x);

int main()
{
    integer x, y, z;
    very big number xnum;
    bool b = true;

    while(b)
        {
            x = 0; x.POS = true;
            do{
                printf("Enter a number:\n>");
            }while(!scanf("%lld", &xnum) && clearbuf());
            try
                {
                    very big number ceiling = (xnum < 0) ? xnum * -1:xnum;
                    for (integer i; i < ((xnum < 0) ? -1 * xnum:xnum); ++i, ++x);
                    if (xnum < 0) x.POS = false;
                    z = factorial(x);
                    printf("You typed: "); x.cout(); printf("\n");
                    printf("%lld! = ", xnum); z.cout();
                    printf("\n\n");
                }
            catch (runtime_error & rt_e)
                {
                    printf("%s\n", rt_e.what());
                    //throw runtime_error("hello world!");
                    //throw rt_e;
                }
            catch (int & n)
                {
                }
            catch (...)
                {
                    printf("Default exception handled.\n");
                }


            do{
                printf("Continue? 1 for Yes 0 for No\n>");
            }while( (!scanf("%d", &b) && clearbuf()) || (b!=0 && b!=1));
            /*}catch(exception &e)
                {
                    printf ("standard exception handled: %s", e.what());
                }
                */
            printf("\n");
        }
}

/*very big factorial(very big x)
{
    if (x < 0)
        throw Negative_Factorial;
    if (x == 0 || x == 1)
        return 1;
    return x*factorial(x-1);
}*/

integer factorial(integer x)
{

    //printf("x = "); x.cout(); printf("\n");
    if (x < 0)
        throw Negative_Factorial;
    if (x == 0 || x == 1)
        return 1;
    integer rv(1), one(1);
    for (integer i(1); i < x; ++i)
        {
            printf("i = "); i.cout(); printf("\n");
            ++one;
            try { rv = rv * one; }
                catch (...){}
            printf("one = "); one.cout(); printf("\n");
            printf("rv = "); rv.cout(); printf("\n");
        }
    return rv;
    //*/
    factorial:
    if (x == (integer)0 || x == (integer)1)
        return 1;
    return x*factorial(x-1);
}

[wtf]

integer.h:

#ifndef INTEGER_H
#define INTEGER_H

#include <string>

#define very long
#define big long
#define number int

very long get_int_size(very long n)
{//I think this is for positive ints only
    int tn = n;
    (n < 0) ? tn *=  -1 :1;
    very long counter = 0, divisor = 1;
    while( (++counter) && (divisor *= 10) )
        if ((tn/divisor) >= 1)
            continue;
        else break;
    return counter;
}

int nth_digit(int n, int d)
{
    int tn = n;
    if (tn<0)
        tn *= -1;  //do I need this?
    int s = get_int_size(tn);
    if (d > s || d < 1)
        return -1;
    int increment = 1,place_holder = 10, counter = 0;
    for (int i = 1; i < d; i++)
        {
            tn = tn - (increment * nth_digit(tn, i));
            place_holder *= 10;
            increment *=10;
        }
    do
        if (tn % place_holder == 0)
            return ((place_holder - (counter*increment)) %place_holder )/increment;
        while( ( (tn +=increment) && (++counter) ) && (tn <= (n + place_holder)) + 10 );
    return -2;
}


bool is_valid_string_for_integer(std::string s)
{
    if ( (s[0] != '-') && (!isdigit(s[0])))
        return false;
    int size = s.size(); int i = 1;
    while(size-1 > i++)
        if (!isdigit(s[i]))
            return false;
    return true;
}

class integer
{
    public:
    short * d;
    bool POS;
    public:
    integer()
    {d = new short[1]; d[0] = 0; size = 1; POS = true;}
    integer(const integer & a){POS = a.POS; d = new short[a.size]; size = a.size; for (int i = 0; i < size; ++i) d[i] = a.d[i];}
    integer(const very big &vln){POS = (vln >= 0) ? true:false; size = get_int_size(vln); d = new short[size]; for (very big number i = size-1; i >= 0; --i) d[i] = nth_digit(vln, size - i ); }
    ~integer(){delete [] d;  }
    int size;
    bool resize(very long ns);
    bool operator ++()
        {
            very big number x = size - 1;
            for (; x>=0; x--)
                if (d[x] < 9)
                    {d[x]++; return true;}
                else d[x] = 0;
            resize(size+1);
            d[0] = 1;
            for (very big number i(1); i < size; ++i)
                d[i] = 0;
            return true;
        }
    bool operator --()
        {
            if (POS)
                {
                    int i = size - 1;
                    for (i; i >= 0; --i)
                        {
                            if (d[i] >= 0)
                                {
                                    return --d[i];
                                }
                        }
                }

        }

    integer operator +(const integer & rhs)
        {
            integer copy(*this), r(rhs);
            for (integer i; i < rhs; ++i)
                ++copy;
            return copy;
        }
    integer operator - (const integer & rhs)
        {
            integer copy(*this);
            for (integer i; i < rhs; ++i)
                --copy;
            return copy;
        }
    bool operator <(const integer & rhs)
        {
            if (POS && !rhs.POS)
                return false;
            if (rhs.POS && !POS)
                return true;
            if (!POS && !rhs.POS)
                {
                    integer a(*this), b(rhs);
                    a.POS = true; b.POS = true;
                    return a > b;
                }
            if (size < rhs.size)
                return true;
            if (size > rhs.size)
                return false;
            if (*this == rhs)
                return false;
            for (int i = 0; i < size; ++i)
                {
                    if (d[i] > rhs.d[i])
                        return false;
                    if (rhs.d[i] > d[i])
                        return true;
                }
            return true;
        }

    bool operator >(const integer & rhs)
        {
            if (POS && rhs.POS)
                {
                    if (size > rhs.size)
                        return true;
                    if (size < rhs.size)
                        return false;
                    if (*this == rhs)
                        return false;
                    for (int i = 0; i < size; ++i)
                        {
                            if (rhs.d[i] > d[i])
                                return false;
                            if (d[i] > rhs.d[i]) return true;
                        }
                            //{std::cout << "i = " << i << ".\n"; std::cout << "d[i] = " << d[i] << ".\n"; std::cout << "rhs.d[i] = " << rhs.d[i] << ".\n"; return false;}

                    return true;
                }
            if (POS && !rhs.POS)
                return true;
            if (!POS && !rhs.POS)
                {
                    integer a(*this), b(rhs);
                    a.POS = true; b.POS = true;
                    return a < b;
                }
            if (!POS && rhs.POS)
                {
                    return false;
                }
        }
    integer operator *(const integer & rhs)
        {
            integer ov(*this), rv; integer r(rhs);
            rv.POS = true; ov.POS = true;
            for (integer i; i < rhs; ++i)
                rv = rv + ov;
            rv.POS = (rhs.POS == POS) ? true:false;
            return rv;
        }
    bool operator +=(const integer & rhs)
    {
        integer temp(*this);
        temp = *this + rhs;
        if (temp == *this + rhs)
            {
                *this = temp;
                return true;
            }
        else return false;
    }

    bool operator == (const integer & rhs)
    {
        if (POS != rhs.POS)
            return false;
        if (rhs.size != size)
            return false;
        for (int i = 0; i < size; ++i)
            if (d[i] != rhs.d[i])
                return false;
        return true;
    }

    bool operator = (const integer & rhs)
    {
        integer temp(rhs);
        if (temp==rhs)
            {
                POS = temp.POS;
                size = temp.size;
                for (int i = 0; i < size; ++i)
                    d[i] = temp.d[i];
                return true;
            }
        else return false;
    }

    bool cout()
        {
            if (!POS)
                printf("-");
            for (int i = 0; i < size; ++i)
                printf("%d", d[i]);
        }
};

bool integer::resize(very long ns)
{
    integer copy(*this);
    size = ns;
    delete [] d;
    d = new short [size];
    for (int i = 0; i < size; ++i)
        d[i] = copy.d[i];
    return true;
}
#endif

Thanks in advance for any help!

[Disch]

#define very long
#define big long
#define number int 

why would you do such a thing? Just so you can write "very big number" instead of "long long"?

*shudders*

EDIT:

As for your actual problem, I might be able to check it later, but it's too much to do at work. I couldn't resist making my above comment though.

*shudders*

[D80DSL3A]

I think I see a problem with your resize() function. If the new size is > the old size then you are exceeding array bounds in the for loop.

bool integer::resize(very long ns)
{
    integer copy(*this);
    size = ns;
    delete [] d;
    d = new short [size];
    for (int i = 0; i < size; ++i)
        d[i] = copy.d[i];// copy has only this->size elements allocated to it. If size > this->size then segfault!
    return true;
}

[wtf]

thats not it. I commented out the lines 7-8 in your above post and the same thing happens. It works for factorials 0-7, sometimes 8, never higher.

I'm now implementing a digit class composed of a bitset<4> and changing my member in integer to be a digit *. Maybe thats it.