debugging my integer class

[wtf]

I have a problem my integer class works well enough incrementing an integer from 0 up to 19, but after that it goes from 19 to 110.

#include <iostream>
#include "integer.h"
using namespace std;

integer x(0), y(0), z(0);

#define display(stream, var) stream << #var << " = "; var.cout(); stream << endl;
#define show(a, b, c) display(cout, x); display(cout, y); display(cout, z);

int main()
{
    const int increments = 30;
    display(cout, x);
    for (int i = 0; i < increments; ++i)
        {
            ++x;
            display(cout, x);
        }
    cout << "now "; display(cout, x);
    return 0;

x = 0
x = 1
x = 2
x = 3
x = 4
x = 5
x = 6
x = 7
x = 8
x = 9
x = 10
x = 11
x = 12
x = 13
x = 14
x = 15
x = 16
x = 17
x = 18
x = 19
x = 110
x = 111
x = 112
x = 113
x = 114
x = 115
x = 116
x = 117
x = 118
x = 119
x = 1110
now x = 1110

here is what I think the problem lies:

inline bool integer::operator ++()
{
    if (POS)
        {
            bool r = number[memory-1].p1();
            if (r)
                return true;
            else
                {
                    VERY BIG i = memory - 2, sp = i - size;
                    for (; i > sp; --i)
                        {
                            number[i+1] = 0;
                            resize(size+1);
                            r = number[memory-size].p1();
                            if (r)
                                return true;
                        }
                }
            return false;
        }
    return false;
}

number is of couse a digit pointer.

[wtf]

digit.h

#ifndef DIGIT_H
#define DIGIT_H
#define baseball

//const short digit_range = 16;
const short digit_range = 10;
const short last_digit = digit_range-1;
const short bits = 4;

#include <string>
#include <bitset>

using namespace std;


template <unsigned bit>
bool operator <(const std::bitset<bit> & l, const std::bitset<bit> & r)
{
    for (int i = bits - 1; i > 0; --i)
        {
            if (l[i] > r[i])
                return false;
            if (l[i] < r[i])
                return true;
        }
    if (l[0] < r[0])
        return true;
    else return false;
}

template <unsigned bit1, unsigned bit2>
bool operator < (const std::bitset<bit1> & l, const std::bitset<bit2> & r)
{
    return bit1 < bit2;
}

template <unsigned bit>
bool operator <=(const std::bitset<bit> & l, const std::bitset<bit> & r)
{
    for (int i = bits - 1; i > 0; --i)
        {
            if (l[i] < r[i])
                return true;
            if (l[i] > r[i])
                return false;
        }
    if (l[0] > r[0])
        return false;
    else return true;
}

template <unsigned bit>
bool operator >= (const std::bitset<bit> & l, const std::bitset<bit> & r)
{
    for (int i = bits - 1; i > 0; --i)
        {
            if (l[i] > r[i])
                return true;
            if (l[i] > r[i])
                return false;
        }
    if (l[0] < r[0])
        return false;
    else return true;
}

template <unsigned bit1, unsigned bit2>
bool operator >= (const std::bitset<bit1> & l, const std::bitset<bit2> & r)
{
    return bit1 >= bit2;
}

class digit
{
    public:bitset<bits> dig;private:
    public:char pv;private:
    public:short vv;private:
    public:
    digit()
        {
            for (int i = 0; i < 4; ++i)
                dig[i] = 0;
        }

    digit(string s)
        {
            bitset<bits> copy(s);
            dig = copy;
        }
    digit(const digit &d)
        {
            pv = d.pv;
            vv = d.vv;
            dig = d.dig;
        }

    digit(int n)
        {
            bitset<bits> temp(n);
            if (n >=digit_range)
                return;//cerr
            else
                dig = temp;
                switch(n)
                    {
                        case 0: pv = '0'; vv = 0;  break;
                        case 1: pv = '1'; vv = 1;  break;
                        case 2: pv = '2'; vv = 2;  break;
                        case 3: pv = '3'; vv = 3;  break;
                        case 4: pv = '4'; vv = 4;  break;
                        case 5: pv = '5'; vv = 5;  break;
                        case 6: pv = '6'; vv = 6;  break;
                        case 7: pv = '7'; vv = 7;  break;
                        case 8: pv = '8'; vv = 8;  break;
                        case 9: pv = '9'; vv = 9;  break;
                        case 10: pv = 'A'; vv = 10; break;
                        case 11: pv = 'B'; vv = 11; break;
                        case 12: pv = 'C'; vv = 12; break;
                        case 13: pv = 'D'; vv = 13; break;
                        case 14: pv = 'E'; vv = 14; break;
                        case 15: pv = 'F'; vv = 15; break;
                        default: break;
                    }
                vv = pv - 48;
        }
    ~digit()
    {}

    bool operator = (const int & rhs)
        {
            if (rhs >= digit_range || rhs < 0)
                return false;
            bitset<bits> temp(rhs);
            dig = temp;
            switch (rhs)
                {
                    case 0: pv = '0'; vv = 0;  break;
                    case 1: pv = '1'; vv = 1;  break;
                    case 2: pv = '2'; vv = 2;  break;
                    case 3: pv = '3'; vv = 3;  break;
                    case 4: pv = '4'; vv = 4;  break;
                    case 5: pv = '5'; vv = 5;  break;
                    case 6: pv = '6'; vv = 6;  break;
                    case 7: pv = '7'; vv = 7;  break;
                    case 8: pv = '8'; vv = 8;  break;
                    case 9: pv = '9'; vv = 9;  break;
                    case 10: pv = 'A'; vv = 10; break;
                    case 11: pv = 'B'; vv = 11; break;
                    case 12: pv = 'C'; vv = 12; break;
                    case 13: pv = 'D'; vv = 13; break;
                    case 14: pv = 'E'; vv = 14; break;
                    case 15: pv = 'F'; vv = 15; break;
                    default: break;
                }
            return true;
        }
    bool operator = (const  digit & rhs)
        {
            if (rhs.vv >= digit_range || rhs.vv < 0)
                return false;
            for (int i = 0; i < bits; ++i)
                dig[i] = rhs.dig[i];
            switch(rhs.vv)
                {
                    case 0: vv = 0; pv = '0'; break;
                    case 1: vv = 1; pv = '1'; break;
                    case 2: vv = 2; pv = '2'; break;
                    case 3: vv = 3; pv = '3'; break;
                    case 4: vv = 4; pv = '4'; break;
                    case 5: vv = 5; pv = '5'; break;
                    case 6: vv = 6; pv = '6'; break;
                    case 7: vv = 7; pv = '7'; break;
                    case 8: vv = 8; pv = '8'; break;
                    case 9: vv = 9; pv = '9'; break;
                    case 10: vv = 10; pv = 'A'; break;
                    case 11: vv = 11; pv = 'B'; break;
                    case 12: vv = 12; pv = 'C'; break;
                    case 13: vv = 13; pv = 'D'; break;
                    case 14: vv = 14; pv = 'E'; break;
                    case 15: vv = 15; pv = 'F'; break;
                    default: break;
                }
            return true;
        }
    bool printf()
        {
            std::printf("%c",pv);
        }
    short value(){return vv;}
    bool operator > (const int & rhs)
        {
            return dig > digit(rhs).dig;
        }
    bool operator < (const int & rhs)
        {
            return dig < digit(rhs).dig;
        }
    bool operator <= (const int & rhs)
        {
            return dig <= digit(rhs).dig;
        }
    bool operator >= (const int & rhs)
        {
            return dig >= digit(rhs).dig;
        }
    bool operator > (const digit & rhs)
        {
            return dig > rhs.dig;
        }
    bool operator < (const digit & rhs)
        {
            return dig < rhs.dig;
        }
    bool operator >= (const digit & rhs)
        {
            return dig >= rhs.dig;
        }
    bool operator <= (const digit & rhs)
        {
            return dig <= rhs.dig;
        }
    bool operator == (const digit & rhs)
        {
            for (int i = 0; i < 4; ++i)
                if (!(dig[i] == rhs.dig[i]))
                    return false;
            return true;
        }
    bool operator != (const digit & rhs)
        {
            return !(*this == rhs);
        }
    bool operator - (const digit & rhs)
        {
            int i = 3;
            for (; i >= 0; --i)
                {
                    if (dig[i] != 0)
                        {
                            dig[i] = 0;
                            for (int j = i+1; i < 4; ++j)
                                {
                                    dig[j] = 1;
                                }
                            return true;
                        }
                }
            return false;
        }
    bool operator ++()
    {
        return ++dig;

    }

    inline bool p1();
};

    inline bool digit::p1()
        {
            if (dig >= last_digit)
                {
                    return false;
                }
            for (int i = 0; i < bits; ++i)
                if (dig[i] == 0)
                    {
                        dig[i] = 1;
                        for (int j = i-1; j >= 0; --j)
                            dig[j] = 0;
                        if (!(++pv && ++vv))
                            throw baseball;
                        return true;
                        return ++pv && ++vv;
                    }
            return false;
        }
#endif

[wtf]

if you need more code, just ask.
edit: bump

[wtf]

bump

[helios]

inline bool integer::operator ++(){
    if (POS){
        //Increment least significant digit.
        bool r = number[memory-1].p1();
        if (r) //Has the LS digit looped around?
            return true;
        else{
            //Yes.
            //Start from the back, skip the final element.
            VERY BIG i = memory - 2, sp = i - size;
            for (; i > sp; --i){
                //On the first iteration, zero the last element.
                number[i+1] = 0;
                //Resize the number.
                //Logic error: not all numbers that fit these conditions should
                //be resized. Examples:
                // 19 -> 20
                // 390 -> 400
                resize(size+1);
                //I belive this says "increment the most significant digit".
                //Logic error: the MS digit shouldn't have to be incremented
                //more than once for each number increment.
                r = number[memory-size].p1();
                //Logic error: this condition will never be false. The loop
                //never runs more than once.
                if (r)
                    return true;
            }
        }
        return false;
    }
    return false;
}

PS: Your code practices make me sick.

[wtf]

Thanks, but does anyone remember the threat from a while back, I think it may have been in the lounce, where they were doing a group project or something on an big num class? I think it would help me immensly for ideas, now that I' ve been workin on my own for a while anyways.

Thanks

[D80DSL3A]

I think this is the one you are asking for: http://cplusplus.com/forum/lounge/32041/