C++ ООП Наследование

[Leet]

Задание выглядит так:
Создать базовый класс Array, в котором определите полемассив подходящеrо типа и поле для хранения количества элементов у текущего объектамассива. Максимально возможный размер массива задается статической константой. Реализуйте конструктор инициализации, задающий количество элементов и начальное значение (по умолчанию О). Реализуйте методы доступа к отдельному элементу, перегpузив операцию индексирования []. При этом должна выплняться проверка Индекса на допустимость.
Реализовать один из классов заданий rлавы 2 как производный класс от класса Array; использовать открытое наследование. Во всех заданиях необходимо реализовать конструкторы инициализации и конструктор без apryMeHToB. Указанные в задании операции реализуются посредством переrpузки подходящих операций.
Во всех заданиях должны быть поддержаны соответствующие операции с присваиванием, ввод с клавиатуры, вывод на экран.
Создать класс Decimal для работы со знаковыми целыми. Знак представить отдельным полем sign.

Класс Decimal я сделал
Помогите Реализовать класс Array, ещё плохо разбираюсь с наследованием и т.д

[Leet]

#include <iostream>
#include <string>
#include <sstream>
using namespace std;
class TDecimal
{
   public:
      enum {SIZE = 100};
   protected:
      unsigned char val[SIZE];
      unsigned size;
      int sing;
   public:
       TDecimal(unsigned long value = 0): size(0)
      {
         *this = value;
      }
      TDecimal(const string& value): size(0)
      {
         *this = value;
      }
      TDecimal& operator = (unsigned long value);
      TDecimal& operator = (const string& value);
      unsigned operator [] (unsigned i);
      TDecimal operator + (const TDecimal& dec);
      TDecimal operator - (TDecimal& dec);
      TDecimal operator * (const TDecimal& dec);
      bool operator == (const TDecimal& dec);
      bool operator < (const TDecimal& dec);
      bool operator > (const TDecimal& dec);
      unsigned GetSize() const
      {
         return size;
      }
      friend ostream& operator << (ostream& os, const TDecimal& digit);
};
//----------------------------------------------//
TDecimal& TDecimal::operator = (unsigned long value)
{
   size = 0;
   while (value)
   {
      val[size++] = value % 10;
      value /= 10;
   }
   return *this;
}
//----------------------------------------------//
TDecimal& TDecimal::operator = (const string& value)
{
   size = value.size();
   for (unsigned i = 0; i < size; ++i)
   {
      val[i] = value[size-i-1]-48;
   }
   return *this;
}
//----------------------------------------------//
unsigned TDecimal::operator [] (unsigned i)
{
   unsigned char digit = 0;
   if (i < size)
   {
      digit = val[size-i];
   }
   return digit;
}
//----------------------------------------------//

[Leet]

TDecimal TDecimal::operator + (const TDecimal& dec)
{
   TDecimal result;
   unsigned mod = 0;
   result.size = (size < dec.size) ? dec.size : size;
   for (unsigned i = 0; i < result.size; ++i)
   {
      result.val[i] = val[i] + dec.val[i] + mod;
      mod = result.val[i] / 10;
      result.val[i] %= 10;
   }
   if (mod)
   {
      result.val[result.size++] = 1;
   }
   return result;
}
unsigned difference (unsigned char *x1,unsigned char *y1, unsigned char *z1, int length,int n,int n1)
{
int x[100],y[100],z[100];
for (int i=0; i<100; i++){x[i]=0; y[i]=0;z[i]=0;} 
for (int i=n-1; i>=0; i--) {x[i]=(int)x1[i]; }
for (int i=n1-1; i>=0; i--) {y[i]=(int)y1[i]; }
    for (int ix = 0; ix < (length - 1); ix++) 
    {
        if (ix < (length - 1))
        {
            x[ix + 1]--;
            z[ix] += 10 + x[ix];
 
        } else  
                z[ix] += x[ix]; 
 
        z[ix] -= y[ix]; 
        if (z[ix] / 10 > 0) 
        {
            z[ix + 1]++; 
            z[ix] %= 10; 
        }
    }
    for (int i=99;i>=0;i--) z1[i]=(unsigned)z[i];
    return 0;
}
TDecimal TDecimal::operator-(TDecimal& dec)
{
   TDecimal result;
   int k;
   result.size=size;
   if (size > dec.size)
{
    result.size = size;
    k = 1;
}
else
    if (dec.size > size)
    {
        result.size = dec.size;
        k = 2;
    }
    else 
        for (unsigned ix = 0; ix < result.size;)
        {
        if ((int)val[ix] > (int)dec.val[ix]) 
            {
                k = 1; 
                break; 
            }
 
        if((int)dec.val[ix] > (int)val[ix]) // если разряд второго числа больше
            {
                k = 2; // значит второе число длиннее первого
                break; // выход из цикла for
            }
        }
        if (k==1) {difference(val,dec.val,result.val, result.size,size,dec.size); result.sing=1; }
        if (k==2) {difference(dec.val,val,result.val, result.size,dec.size,size); result.sing=-1; }
   return result;
}
TDecimal TDecimal::operator*(const TDecimal& dec)
    {
    TDecimal result;
    result.size = dec.size + size + 1;
 
    for (unsigned ix = 0; ix < size; ix++)
       for (unsigned jx = 0; jx < dec.size; jx++)
           result.val[ix + jx] += val[ix] * dec.val[jx];
 
    for (unsigned ix = 0; ix < result.size; ix++)
    {
     result.val[ix + 1] +=  result.val[ix] / 10;
     result.val[ix] %= 10;
    }
while ((int)result.val[result.size] == 0)
    result.size-- ;
return result;
    }
//----------------------------------------------//
bool TDecimal::operator == (const TDecimal& dec)
{
   bool eq = (size == dec.size);
   if (eq)
   {
      for (unsigned i = 0; i < size; ++i)
      {
         if (size == dec.size)
         {
            eq = false;
            break;
         }
      }
   }
   return eq;
}
//----------------------------------------------//
bool TDecimal::operator < (const TDecimal& dec)
{
   bool less = (size < dec.size);
   if ((less == false) && (size == dec.size))
   {
      for (unsigned i = size-1; i < size; --i)
      {
         if (val[i] != dec.val[i])
         {
            less = (val[i] < dec.val[i]);
            break;
         }
      }
   }
   return less;
}
//----------------------------------------------//
bool TDecimal::operator > (const TDecimal& dec)
{
   bool larger = (size > dec.size);
   if ((larger == false) && (size == dec.size))
   {
      for (unsigned i = size-1; i < size; --i)
      {
         if (val[i] != dec.val[i])
         {
            larger = (val[i] > dec.val[i]);
            break;
         }
      }
   }
   return larger;
}
//----------------------------------------------//
ostream& operator << (ostream& os, const TDecimal& digit)
{
if (digit.sing==-1) os<<"-";
   for (unsigned i = digit.size-1; i < digit.size; --i)
   {
      os << (int) digit.val[i];
   }
   return os;
}
//----------------------------------------------//
int main()
{
   TDecimal a("12435435436234632");
   TDecimal b("242341523163464573");
   cout << "a = " << a << endl;
   cout << "b = " << b << endl;
   cout << "a+b = " << (a+b) << endl;
   cout << "a-b = " << (a-b) << endl;
   cout << "b-a = " << (b-a) << endl;
   cout << "b*a = " << b*a << endl;
   system ("PAUSE");
   return 0;
}

Это класс Decimal, который я написал, теперь нужно создать класс Array.