#include <iostream>

using namespace std;

class Tablica
  {
   private:
   unsigned R;
   long *T;
   public:
   Tablica(unsigned Rozmiar=0); // uzycie: Tablica T(3),A;
   Tablica(const Tablica &Tb); // uzycie: przekazywanie i zwracanie przez wartosc. Tablica T(3),B(T),A=T;
   ~Tablica(); // uzycie: automatycznie;
   operator unsigned()const { return R; } // zwraca rozmiar; uzycie: Tablica T(3); if(T<4) ...
   unsigned operator ()()const { return R; } // zwraca rozmiar; uzycie: Tablica T(3); if(T()<4) ...
   unsigned operator ()(unsigned Rozmiar); // zmienia rozmiar; uzycie: Tablica T(3); T(8);
   long &operator [](unsigned P) { return T[P]; } // uzycie: Tablica T(3); T[2]=5;
   const long &operator [](unsigned P)const { return T[P]; } // uzycie: const Tablica T(3); long x=T[0];
   Tablica &operator=(const Tablica &Tb); // uzycie: const Tablica T(3),A; A=T;
   Tablica &operator<<(long x); // dopisuje wartosc x do tablcy; uzycie: Tablica A; A<<1<<2<<3;
   Tablica &operator<<(const Tablica &Tb); // dopisuje cala tablice do tablcy; uzycie: Tablica A(2),B(3); A<<B;
  };

Tablica::Tablica(unsigned Rozmiar):R(Rozmiar),T(R?new long[R]:0)
  {
   //for(unsigned i=0;i<R;++i) T[i]=0;
   memset(T,0,R*sizeof(long));
  }

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

Tablica::~Tablica()
  {
   if(R) delete[] T;
  }

unsigned Tablica::operator ()(unsigned Rozmiar) // zmienia rozmiar;
  {
   long *N=Rozmiar?new long[Rozmiar]:0;
   if(R)
     {
      //unsigned Min=R<Rozmiar?R:Rozmiar;
      //for(unsigned i=0;i<Min;++i) N[i]=T[i];
      memcpy(N,T,(R<Rozmiar?R:Rozmiar)*sizeof(long));
      delete[] T;
     }
   if(Rozmiar>R)
     {
      //for(unsigned i=R;i<Riozmiar;++i) N[i]=0;
      memset(N+R,0,(Rozmiar-R)*sizeof(long));
     }
   T=N;
   R=Rozmiar;
  }

Tablica &Tablica::operator =(const Tablica &Tb) // To co destruktor potem to co konstruktor kopiujacy
  {
   if(R) delete[] T;
   R=Tb.R;
   T=R?new long[R]:0;
   //for(unsigned i=0;i<R;++i) T[i]=Tb.T[i];
   memcpy(T,Tb.T,R*sizeof(long));
  }
  
Tablica &Tablica::operator <<(long x)
  {
   // Tablica &t=*this; unsigned r=t; t(r+1); t[r]=x;
   // unsigned r=*this; (*this)(r+1); (*this)[r]=x;
   unsigned r=operator unsigned(); // uzywamy operator jako metode;
   operator ()(r+1); // uzywamy operator jako metode;
   operator [](r)=x; // uzywamy operator jako metode;
   return *this;
  }  

Tablica &Tablica::operator<<(const Tablica &Tb)
  {
   unsigned r=operator unsigned(); // uzywamy operator jako metode;
   operator ()(r+Tb); // uzywamy operator jako metode;
   //for(unsigned i=0;i<Tb;++i) T[i+r]=Tb.T[i];
   memcpy(T+r,Tb.T,Tb*sizeof(long));
   return *this;
  }

ostream &operator <<(ostream &s,const Tablica &T)// uzycie: Tablica T(2); cout<<T<<endl;
  {
   s<<'{';
   for(unsigned i=0;i<T;++i)
     { 
      if(i) s<<',';
      s<<T[i];
     }
   return s<<'}';
  }

int main(void)
{
        while(true)
        {
          cout << "Podaj polecenie: ";
          switch(cin.get())
          {
            case '+':
              switch (cin.get())
              {
                case 'P':
                  cout << endl << "Napisales P" << endl;
                  break;
                case 'K':
                  cout << endl << "Napisales K" << endl;
                  break;
                case 'T':
                  cout << endl << "Napisales T" << endl;
                  break;
                default:
                  cout << "Blad." << endl;
                  break;
             }
            break;
            case '$':
                exit(1);
            break;
            case '\n':
            continue;
            default:
                cout << "Blad." << endl;
                break;
          }
        }
}