Proj: "Dzielenie przez siebie liczb zap. w dwoch tab in

Zwracam sie z prosba o pomoc w rozwiazaniu meczacego mnie od jakiegos czasu problemu.
Sprawa polega na tym, iz usiluje napisac klase, ktora odpowiedzialna bedzie za przetwarzanie tablic typu int, zawierajacych bardzo duze liczby calkowite zapisane w sposob sekwencyjny np. takie:

int tab1[] = {1,2,3,4,5,6,7,8};
int tab2[] = {2};

Teraz np. tab1[3] bedzie mialo wartrosc 4 - i tak tez konstruktor alokuje te dane w tych tablicach typu int (cyfra po cyfrze), wczesniej otrzymujac jako parametr wejsciowy przy deklaracji/inicjacji obiektu ciag znakow char* reprezentujacy duza cyfre np.

KlasaDuzaCalkowita obiekt1("123450000000000000000000");

UPROSZCZONY KOD KONSTRUKTORA:
DuzaCalkowita::DuzaCalkowita(const char *napis) //definicja konstruktora kopiującego.
{
int i,j;
int dlg = strlen(napis);
for(i=0; i<=MAX-1; i++) intTablica=0; //inicjacja zm. skladowej - tab. przechowujacej liczbe (wypelnianie zerami).

for(i=MAX-dlg; i<=MAX-1; i++) // MAX, to stała - maksymalna wielkosc tablicy intTablica - składowej.
intTablica = napis-'0'; // lub: if(intTablica != '0') { intTablica = napis; }
}

Jak widac, dzieki takiemu zapisowi liczby moga byc bardzo duze (tutaj maksymalnie o wielkosci tablicy intTablica - w tym przykladzie MAX). Skadową klasy jest wiec taka tablica, w ktorej kazdy z obiektow przechowuje swoja "duza liczbe". Klasa dokonuje wszystkich podstawowych operacji arytmetycznych (np. obiekt1 = obiekt2 + obiekt3) dzieki przeciazonym operatorom dla tych obiektow np.

KlasaDuzaCalkowita obiekt1("1234"), obiekt2("2222"), obiekt3;
obiekt3 = obiekt1 + obiekt2;

I taka prosta operacja arytmetyczna odbywa sie w przeciazonym operatorze dodawania mniej-wiecej tak jak dodawanie w slopku wiec:

obiekt1: 1234
obiekt2: 2222
obiekt3: 3456

UPROSZCZONY KOD PRZECIAZONEGO OPERATORA DODAWANIA:DuzaCalkowita DuzaCalkowita::operator+(const char *napis)
{
KlasaDuzaCalkowita pom, prawy(napis);
int przeniesienie=0;

for(int i=MAX-1;i>=0;i--) //iteracja dodawania.
{
pom.intTablica = intTablica+prawy.intTablica+przeniesienie;
if(pom.intTablica > 9)
{
pom.intTablica = pom.intTablica%10;
przeniesienie=1;
}
else
przeniesienie=0;
}

return pom;
}

Gdzie tkwi problem!!!
Mimo usilnych staran, nie wpadlem jeszcze na odpowiednio wydajny sposob przeciazenia operatora dzielenia ' / '.
Probowalem dokonac tego na rozne sposoby, ale albo dzialalo zbyt wolno, albo generowalo bledne wyniki.
Dlatego bardzo prosze o pomoc w rozwiazaniu problemu dot. przeciazonego operatora dzielenia ' / ', ktory bedzie dzialal na ww. zasadach.

Moje podejscie do sprawy:
[mamy sytulacje: obiekt1/obiekt2].
- oszacowac dlg. obiektu po lewej i po prawej stronie dzialania, co pozwoli oszacowac dlugosc wyniku,
- badanie ile razy obiekt2 zmiesci sie w obiekcie1
(tu tkwi problem - mozna to zrobic nawet na zasadzie dzielenia w slupku - tak jak powyzsze dodawanie, ale chyba nie uniknie sie wtedy rekurencji)
- zwrocenie wyniku przez funkcje przec. operatora ' / '.

Dziekuje za doczytanie tego listu az do tego mometu i bardzo prosze o przeslanie ewentualnych propozycji rozwiazania tego problemu pod adres: przemek-michalski@wp.pl , za wszelka pomoc dziekuje.

PS.
Uzywam VC++ 6 (kalsa jest pisana w ANSI/ISO C++).
Przepraszam za list w formacie HTML.