[C++] Sortowanie alfabetyczne elementów klasy

--------------------------------------MAIN----------------------------------------------------

int _tmain( int argc, _TCHAR * argv[] )
{
    programmer ttab1[] = {
        programmer( "Jan" ),
        programmer( "Piotr" ),
        programmer( "Anna" ),
        programmer( "Beata" ),
        programmer( "Barbara" ),
    };
   
   
    team tm( sizeof( ttab1 ) / sizeof( programmer ), ttab1 );
    tm.disp();
    tm.sort();
    tm.disp();
   
    system( "pause" );
    return 0;
}

--------------------------------------TEAM.H----------------------------------------------------

class team
{
    programmer * p;
    size_t nitems; //ilosc programistow w teamie
public:
    team()
        : p( NULL )
    { }
    //-----------konstruktor kopiujący--------//
    team( team & ob );
    team( size_t noitems, programmer * tab ); //tab - tablica programistow, tworzacych team
    //noitems - liczba tych programistow
    ~team();
    void disp();
    void sort(); //sortuje alfabetycznie programistow w teamie wedlug imion
};



--------------------------------------TEAM.CPP----------------------------------------------------

team::team( size_t noitems, programmer * tab )
{
    nitems = noitems;
    try
    {
        p = new programmer[ noitems ];
        for( size_t it = 0; it < noitems; ++it )
             p[ it ] = tab[ it ];
       
    }
    catch( bad_alloc )
    {
       
    }
}


team::~team()
{
    if( p )
         delete[] p;
   
    p = NULL;
}


void team::disp()
{
    if( p )
    {
        for( size_t it = 0; it < nitems; ++it )
             p[ it ].disp();
       
    }
    cout << "=========================\n";
}


team::team( team & ob )
{
    if( !p ) p = NULL;
    else
    {
        p = new programmer[ sizeof( ob.p ) ];
        p = ob.p;
        nitems = ob.nitems; //niepotrzebne (chyba)
    }
}

void team::sort()
{
    int i = 0, j = 0;
    char litera;
    for( i = 0; i < nitems; i++ )
    for( j = 0; j < nitems; j++ )
    {
       
        //SORTOWANIE
       
       
    }
   
   
   
   
}

--------------------------------------PROGRAMMER.H------------------------------------------------

class programmer
{
    char * name;
public:
    programmer()
        : name( NULL )
    { }
    programmer( char * nname );
    //------------konstruktor kopiujący--------/
    programmer( programmer & ob );
    ~programmer();
    void disp();
private:
    void alloc( size_t len );
};


--------------------------------------PROGRAMMER.CPP----------------------------------------------

programmer::programmer( char * nname )
{
    size_t len = strlen( nname ) + 1;
    alloc( len );
    strcpy_s( name, len * sizeof( char ), nname );
}


programmer::~programmer()
{
    if( name )
         delete[] name;
   
    name = NULL;
}

void programmer::disp()
{
    if( name )
         cout << name << endl;
   
}

void programmer::alloc( size_t len )
{
    try
    {
        name = new char[ len ];
        name[ 0 ] = '\0';
    }
    catch( bad_alloc )
    {
       
    }
}


programmer::programmer( programmer & ob )
{
    if( !name ) name = NULL;
    else
    {
        name = new char[ sizeof( ob.name ) ];
        name = ob.name;
    }
}