#include <iostream>
#ifdef __BORLANDC__
#else
  using namespace std;
#endif

template<typename Typ>
class Tablica
  {
   private:
   unsigned R;
   Typ *T;
   public:
   Tablica(unsigned Rozmiar=0);
   Tablica(const Tablica &Tb);
   ~Tablica();
   unsigned Rozmiar()const { return(R); }
   void Rozmiar(unsigned NowyR);
   unsigned operator()()const { return(R); } // jak unsigned Rozmiar()const
   void operator()(unsigned NowyR) { Rozmiar(NowyR); }
   Typ &operator[](unsigned i);
   const Typ &operator[](unsigned i)const;
   Tablica &operator=(const Tablica &Tb);
  };

template<typename Typ>
Tablica<Typ>::Tablica(unsigned Rozmiar):
  R(Rozmiar),
  T(R?new Typ[R]:0)
  {
  }

template<typename Typ>
Tablica<Typ>::Tablica(const Tablica<Typ> &Tb):
  R(Tb.R),
  T(R?new Typ[R]:0)
  {
   //memcpy(T,Tb.T,R*sizeof(Typ));
   for(unsigned i=0;i<R;++i) T[i]=Tb.T[i];
  }

template<typename Typ>
Tablica<Typ>::~Tablica()
  {
   if(R) delete[] T;
  }

template<typename Typ>
void Tablica<Typ>::Rozmiar(unsigned NowyR)
  {
   Typ *NowyT=NowyR?new Typ[NowyR]:0;
   if(R)
     {
      //memcpy(NowyT,T,(R<NowyR?R:NowyR)*sizeof(Typ));
      unsigned N=R<NowyR?R:NowyR;
      for(unsigned i=0;i<N;++i) NowyT[i]=T[i];
      delete[] T;
     }
   T=NowyT;
   R=NowyR;
  }

template<typename Typ>
Typ &Tablica<Typ>::operator[](unsigned i)
  {
   if(i>=R) throw i;
   return(T[i]);
  }

template<typename Typ>
const Typ &Tablica<Typ>::operator[](unsigned i)const
  {
   if(i>=R) throw i;
   return(T[i]);
  }

template<typename Typ>
Tablica<Typ> &Tablica<Typ>::operator=(const Tablica<Typ> &Tb)
  {
   if(R) delete[] T;
   R=Tb.R;
   T=R?new Typ[R]:0;
   //memcpy(T,Tb.T,R*sizeof(Typ));
   for(unsigned i=0;i<R;++i) T[i]=Tb.T[i];
   return(*this);
  }

template<typename Typ>
ostream &operator<<(ostream &s,const Tablica<Typ> &Tb)
  {
   s<<'{';
   for(unsigned i=0;i<Tb();++i) // uzycie operatora: unsigned operator()()const
     {
      if(i) s<<';';
      s<<Tb[i]; // uzycie operatora: const Typ &operator[](unsigned i)const
     }
   return(s<<'}');
  }

template<typename Typ>
istream &operator>>(istream &s,Tablica<Typ> &Tb)
  {
   for(unsigned i=0;i<Tb();++i) // uzycie operatora: unsigned operator()()const
     {
      s>>Tb[i]; // uzycie operatora: Typ &operator[](unsigned i)
     }
   return(s);
  }

int main()
  {
   int N;
   cout<<"Podaj rozmiar: ";
   cin>>N;
   Tablica<int> T(N),A,B(7);
   for(unsigned i=0;i<T();++i) T[i]=(double)i/2+1;

   cout<<"T="<<T<<endl;
   cout<<"A="<<A<<endl;
   cout<<"B="<<B<<endl;

   Tablica<int> C=T;
   //cout<<C[1000]<<endl; // wygeneruje wyjatek
   A(N); // zmiana rozmiaru: void operator()(unsigned NowyR)
   for(unsigned i=0;i<A();++i) A[i]=(double)i/4+1;
   cout<<"A="<<A<<endl;
   B=A; // Tablica<Typ> &operator=(const Tablica<Typ> &Tb)
   cout<<"Wprowadz B[1.."<<B()<<"]:"<<endl;
   cin>>B;
   cout<<"B="<<B<<endl;

   Tablica<Tablica<int> > TT(3);
   for(unsigned i=0;i<TT();++i) TT[i](5);

   int i=0;
   for(unsigned y=0;y<TT();++y)
     {
      for(unsigned x=0;x<TT[y]();++x)
        {
         TT[y][x]=++i;
        }
     }

   for(unsigned y=0;y<TT();++y)
     {
      for(unsigned x=0;x<TT[y]();++x)
        {
         if(x) cout<<'\t';
         cout<<TT[y][x];
        }          
      cout<<endl;
     }

   cout<<"TT="<<TT<<endl;
   cout<<"Podaj TT: ";
   cin>>TT;
   cout<<"TT="<<TT<<endl;

#ifdef __BORLANDC__
   cin.ignore(1024,'\n');
   cin.get();
#endif
   return(0);
  }