Szablon klasy, dla tablicy wielowymiarowej

#include <iostream>
#include <memory.h>

using namespace std;

template < typename TYP > class TArray
{
    static const unsigned DOMYSLNY_ROZMIAR = 5;
protected:
    TYP * m_pnTablica;
    unsigned m_uRozmiar;
public:
    explicit TArray( unsigned uRozmiar = DOMYSLNY_ROZMIAR )
        : m_uRozmiar( uRozmiar )
        , m_pnTablica( new TYP[ uRozmiar ] )
    { }
    TArray( const TArray & );
   
    ~TArray() { delete[] m_pnTablica; }
    TYP Pobierz( unsigned uIndeks ) const
    {
        if( uIndeks < m_uRozmiar )
             return m_pnTablica[ uIndeks ];
        else
             return 0;
       
    }
    bool Ustaw( unsigned uIndeks, TYP nWartosc )
    {
        if( uIndeks >= m_uRozmiar ) return false;
       
        m_pnTablica[ uIndeks ] = nWartosc;
        return true;
    }
    unsigned Rozmiar() const { return m_uRozmiar; }
    TYP & operator []( unsigned uIndeks ) { return m_pnTablica[ uIndeks ]; }
   
    // Szablon metody
    template < typename U >
    TArray < TYP >& operator =( TArray < U >& );
};

template < typename TYP >
TArray < TYP >::TArray( const TArray & aTablica )
{
    m_uRozmiar = aTablica.m_uRozmiar;
    m_pnTablica = new TYP[ m_uRozmiar ];
    memcpy( m_pnTablica, aTablica.m_pnTablica, m_uRozmiar * sizeof( TYP ) );
}

template < typename TYP >
template < typename U >
TArray < TYP >& TArray < TYP >::operator =( TArray < U >& aTablica )
{
    // niszczymy w³asn¹ tablicê
    delete[] m_pnTablica;
    // tworzymy now¹, o odpowiednim rozmiarze
    m_uRozmiar = aTablica.Rozmiar();
    m_pnTablica = new TYP[ m_uRozmiar ];
    // przepisujemy zawartoœæ tablicy przy pomocy pêtli
    for( unsigned i = 0; i < m_uRozmiar; ++i )
         m_pnTablica[ i ] = aTablica[ i ];
    // zwracamy referencjê do w³asnego obiektu
    return * this;
}

template < typename TYP > class TDynamicArray
    : public TArray < TYP >
{
public:
    bool ZmienRozmiar( unsigned );
};

template < typename TYP > bool TDynamicArray < TYP >::ZmienRozmiar( unsigned uNowyRozmiar )
{
    if( !( uNowyRozmiar > this->m_uRozmiar ) ) return false;
   
    TYP * pNowaTablica = new TYP[ uNowyRozmiar ];
    memcpy( pNowaTablica, this->m_pnTablica, this->m_uRozmiar * sizeof( TYP ) );
    delete[] this->m_pnTablica;
    this->m_pnTablica = pNowaTablica;
    this->m_uRozmiar = uNowyRozmiar;
    return true;
}

/* Specyfikacja wielowymiarowej */

template < typename TYP > class TArray < TArray < TYP > >
{
    static const unsigned DOMYSLNY_ROZMIAR = 5;
private:
    // wskaźnik na tablicę
    TYP * m_pTablica;
    // wymiary tablicy
    unsigned m_uRozmiarX;
    unsigned m_uRozmiarY;
   
public:
    // konstruktor i destruktor
    explicit TArray( unsigned uRozmiarX = DOMYSLNY_ROZMIAR, unsigned uRozmiarY = DOMYSLNY_ROZMIAR )
        : m_uRozmiarX( uRozmiarX )
        , m_uRozmiarY( uRozmiarY )
        , m_pTablica( new TYP[ uRozmiarX * uRozmiarY ] )
    { }
   
    ~TArray() { delete[] m_pTablica; }
   
    //-------------------------------------------------------------
    // metody zwracające wymiary tablicy
    unsigned RozmiarX() const { return m_uRozmiarX; }
    unsigned RozmiarY() const { return m_uRozmiarY; }
   
    //-------------------------------------------------------------
    //operator () do wybierania elementów tablicy
    TYP & operator ()( unsigned uX, unsigned uY ) { return m_pTablica[ uY * m_uRozmiarX + uX ]; }
    TYP & operator []( unsigned uIndex )
    {
        static TYP uIndexY = uIndex;
        return uIndex;
    }
};

int main()
{
    cout << "Hello world!" << endl;
    TArray < TArray < int > > Array( 1, 1 );
    cout << Array( 0, 0 ) << endl;
    cout << Array[ 1 ][ 1 ] << endl;
    return 0;
}