HI, im working on this code which is going to be tested with only positive numbers. I am having trouble with the overloaded + and *, it gives my an error and closes the program down. Is there anything wrong with them or something else has to be fixed???
thanks in advance.

bigInt.h
Code:
//class bigInt implements big integers by storing the digits of a big
//integer in a private vector data member called digit. Since it uses a
//vector the size of the big integer can be indefinitely large. This class 
//implements input/output of bigInts, addition/multiplication/pre-increment 
//of bigInts, assignment of a bigInt or long int to a bigInt and ==/< 
//comparison of bigInts. The operators addition/multiplication/pre-increment/<
//only work for big integers >= 0. By adding additional code they could be 
//made to work for negative big integers also.
#ifndef _bigInt_h
#define _bigInt_h

#include <iostream>
#include <vector>
#include <string>

using namespace std;

class bigInt
{
public:
    bigInt();                //default constructor, defined
    bigInt(long int k);      //construct bigInt with value like k, defined
    bigInt(const string& s); //construct bigInt with value like string s ,defined
    
    void print(ostream& os) const; //function to output a bigInt, defined
    void read(istream& is);        //function to input a bigInt, defined

    bigInt operator+(const bigInt& bi2) const;  //overloads + operator
    bigInt operator*(const bigInt& bi2) const;  //overloads * operator
    bigInt& operator++();                       //overloads pre-increment op, defined
   
    const bigInt& operator=(const bigInt& bi2);  //copy assignment operator, defined
    const bigInt& operator=(long int i);  //converts i to bigInt and assigns
    
        //overload comparison operators
    bool operator==(const bigInt& bi2) const; //defined
    bool operator<(const bigInt& bi2) const;//defined
      
private:
    char sign;         //stores the sign '+' or '-'. Not really 
                       //needed in this program because you only have 
                       //to handle positive numbers (numbers >= 0), but
                       //would be needed in a complete program.
    vector<int> digit; //vector to store digits of a bigInt with
                       //one digit in each element of the vector.
                       //A more efficient version of the program
                       //would store several digits in each element.
                       //digit[0] is the 1's digit, digit[1] is the 10's
                       //digit, digit[2] is the 100's digit, etc.
                       
    void convertString(const string& s); //converts string into bigInt 
                                         //representaion., defined
 };   
    
    //overloads << and >> operators as non-member functions using
    //public member functions print and read.
ostream& operator<<(ostream& os, const bigInt& bi); //defined
istream& operator>>(istream& is, bigInt& bi);//defined

#endif
bigInt.cpp
Code:
#include <iostream>
#include <string>
#include <cctype>
#include <cstdlib>

#include "bigInt.h"

using namespace std;

bigInt::bigInt()
{
}

bigInt::bigInt(long int i)
/*this function should determine whether i is positive or
     negative and set the sign accordingly. It then extracts
     the digits from i and stores them in the vector digit.
     This can be done by nextdigit = i % 10; i = i / 10; For
     example if i is 456 then nextdigit = 456 % 10; sets 
     nextdigit to 6 and i = i / 10; sets i to 45 so i is ready 
     to have the next digit extracted.
   */
{
	long int nextdigit;
	if(i < 0) 
	{
		sign = '-';
		i=abs(i);
	}
	else sign='+';

	while(i != 0)
	{
		nextdigit=i % 10;
		digit.push_back(nextdigit);
		i=i/10;
		
	}

}

bigInt::bigInt(const string& s)
{  convertString(s);
}

void bigInt::print(ostream& os) const
{  int k;
   
    os<<sign;
    for(k = digit.size() - 1; k >= 0; k--) //print right to left  
       os<<digit[k];                       //high order digits first
}

void bigInt::read(istream& is)
{  string s;

   is>>s;
   convertString(s);
}

bigInt& bigInt::operator++() //++ only works correctly for positive bigInts
{ int i, sum, newdigit, carry;
  
  sum = digit[0] + 1;
  newdigit = sum % 10;
  carry = sum / 10;
  digit[0] = newdigit;
  i = 1;
  while(i < digit.size() && carry != 0)
  {  sum = digit[i] + carry;
     newdigit = sum % 10;
     carry = sum / 10;
     digit[i] = newdigit;
     i++;
  }
  if (carry != 0) digit.push_back(carry);
  return *this;
}

void bigInt::convertString(const string& s)
{  int j, k, nextdigit;
   
   if (s[0] == '+' || s[0] == '-')
   {   sign = s[0];
       k = 1; //process from subscript 1 so sign not considered again
   }
   else
   {   sign = '+';  //no sign in string then positive number
       k = 0;       //no sign so process from subscript 0
   }
   
   digit.resize(0); //resize the vector digit to 0
   for(j = s.size() - 1; j >= k; j--) //process digits in string from right 
      if (isdigit(s[j]))              //to left - low order digits first
      {  nextdigit = s[j] - '0'; //convert character digit to int
         digit.push_back(nextdigit);
      }
      else
      {  cerr<<"Bad string argument for convertString function"<<endl;
         cin.get(); cin.get(); //to pause console i/o screen
         exit(1);
      }
}

ostream& operator <<(ostream& os, const bigInt& bi)
{
	bi.print(os);
	return os;
}

istream& operator >>(istream& is, bigInt& bi)
{
	bi.read(is);
	return is;
}

bigInt bigInt::operator *(const bigInt& bi2)const
{
	int mul;
	int carry=0;
	int k;
	int len=this->digit.size();
	bigInt tem;

	if(len < bi2.digit.size())len=bi2.digit.size();

	for(k=0;k<len;k++)
	{
		mul=this->(digit[k]*bi2.digit[k])+carry;
		carry=sum/10;
		mul=mul%10;
		tem.digit.push_back(mul);

	}
	if(carry != 0)tem.digit.push_back(carry);

	return temp;
}

bigInt bigInt::operator +(const bigInt& bi2)const
{
	int sum;
	int carry=0;
	int k;
	int len=this->digit.size();
	bigInt temp;

	if(len < bi2.digit.size())len=bi2.digit.size();

	for(k=0;k < len; k++)
	{
		sum=this->digit[k]+bi2.digit[k]+carry;
		carry=sum/10;
		sum=sum%10;
		temp.digit.push_back(sum);
	}
	if(carry != 0)temp.digit.push_back(carry);
	return temp;
}

const bigInt& bigInt::operator =(long int i)
{
	bigInt temp(i);
	int k=0;

	this->digit.resize(0);

	while(k < temp.digit.size())
	{
		this->digit[k]=temp.digit[k];
		k++;
	}
	return *this;



}

const bigInt& bigInt::operator =(const bigInt& bi2)
{
	int i=0;

	while(i < this->digit.size())
	{
		this->digit.pop_back();
		i++;
	}
	this->digit.resize(0);
	i=0;

	while(i < bi2.digit.size())
	{
		this->digit[i]=bi2.digit[i];
		i++;
	}
	return *this;
}

bool bigInt::operator ==(const bigInt& bi2)const
{
	bool isIT=false;
	
	
	if( bi2.digit.size() == this->digit.size() )
	{	
		for(int i=0; i < this->digit.size();i++)
		{
			if(bi2.digit[i] != this->digit[i])return isIT; 
		}
		isIT=true;

	}

	return isIT;;

}

bool bigInt::operator < (const bigInt& bi2)const
{
	bool isIt=false;

	if(this->digit.size() != bi2.digit.size())return( this->digit.size() < bi2.digit.size());

	for(int i=0;i < this->digit.size();i++)
	{
		if(this->digit[i] < bi2.digit[i])return isIt=true;
	}
	return isIt;


}
testbigInt.cpp
Code:
#include <iostream>
#include "bigInt.h"

int main()
{  
	bigInt bi1/*("+19999999999999999999999999999999999")*/(9000), bi2;
	


   
   ++bi1;
   bi1.print(cout);
   cout<<endl;
   cout<<"Enter a bigInt: ";
   bi2.read(cin);
   ++bi2;
   bi2.print(cout);
   cout<<endl;
   bi2.print(cout);
   cout<<endl;
   cin.get();
   cin.get();  
   return 0;
}