Delegacja + pytanie do zadania na studia

Witam, na studiach dostałem takie zadanie(w załączniku), nie wiem o co dokładnie chodzi, z tego co mi się zdaje to mam zrobić klasy pochodne od Klient(polimorfizm) ale w jaki sposób mam zmieniać ich typy.
Klienci są trzymani w vektorze wskaźników typu Klient.
Pierwotny pomysł to zastępowanie aktualnego obiektu nowym obiektem wybranego typu (konstruktor kopiujący)
Usunięcie obiektu - przy pomocy delete, do wskaźnika który wskazywał na stary obiekt podać adres nowego Klienta(wskaźnik na odpowiedni typ klasy pochodnej od klasy Klient)
Drugie pytanie to o co chodzi z delegacją, czy w tym zadaniu chodzi o to że zmiana typu ma się odbywać w klasie która przechowuje vektor do Klientów??
Prosiłbym o zrewidowanie mojego toku myślenia i ewentualnie naprowadzenie na poprawne rozwiązanie.
Z GÓRY WIELKIE DZIĘKI!!!!!

Delegacja polega na tym, że zlecasz wykonanie jakiejś operacji innemu obiektowi.
Myśle że prowadzącemu może chodzić o coś w stylu dekoratora więc np. new WeirdClient(new Client("Kowalski"));

Czyli mam to rozumieć tak że tworzę nową klasę TypKlienta i po niej dziedziczę KlientUpustLinowy, KlientUpustSchodkowy, KlientUpustStały . A potem umieszczam instancje(lub wskaźnik) tej klasy w klasie Klient i właśnie ta klasa zajmowałaby się sprawdzeniem ilości wypożyczeń oraz wyliczeniem upustu?
Oto kod przedstawiajacy mój tok myślenia
Pomijam ciała metod oraz dla zrozumienia pisze po polsku nazwy klas oraz metod

class Klient
{
private:
/*
.
.
.
*/
   TypKlienta * aktualnyTypKlienta
public:
   Klient(string imie, string nazwisko);
   ~Kilent();
   void zmienTypKlienta(TypKlienta * nowyTyp);
}

class TypKlienta
{
private:
   int maxWypozyczen;
public:
   TypKlienta(int maxWypozyczen) // Konstruktory klasy dziedziczącej będą wywoływały ten konstruktor
   virtual float wyliczUpust();  // każde dziecko będzie wyliczało upust osobno
}

Nie, delegacja zwykle oznacza że implementujesz ten sam interfejs ale nie dziedziczysz klas między sobą.

definicja interfejsu tłumacząca mój tok myślenia Interfejs to klasa abstrakcyjna która ma tylko i wyłącznie metody czysto wirtualne i nie ma żadnych pól.

Zasadniczo interfejsy się dziedziczy - składa się na to to że posiadają tylko czysto wirtualne metody
klasa zmodyfikowana tak żeby była traktowana jako interfejs

class TypKlienta
{
private:
public:
   TypKlienta(); 
   virtual float wyliczUpust()=0;  // każde dziecko będzie wyliczało upust osobno
}

Przyznam się że przez moment wiedziałem(zdawało mi się) o co chodzi lecz niestety po Twoim poście wróciłem do punktu wyjścia ;/

Można to zrobic np. w stylu:

class Client{
    public:
        virtual float discount()=0;
        virtual int maxCars()=0;
        virtual string introduceYourself()=0;
}

class BasicClient: public Client{
    private:
        string name;
        string surname;
    public:
        BasicClient(string n, string s):name(n),surname(s){}
        virtual float discount() { return 0.0;}
        virtual int maxCars() { return 0; }
        virtual string introduceYourself() {return "Klient "+name+" "+nazwisko;}
}

class UberClient: public Client{
    private:
        Client* baseClient;
    public:
        UberClient(Client* b): baseClient(b) {}
        virtual float discount() { cośtam}
        virtual int maxCars() { cośtam}        
        virtual string introduceYourself() {return baseClient.introduceYourself()+", cośtam dodatkowego"; }
}

I możesz wtedy mieć dowolnego klienta i "dekorować" go dodatkowym typem. Wtedy jeden klient moze mieć wiele typów jednocześnie, nakładanych na siebie.

Ale można to zrobić też zupełnie inaczej i delegować operacje klienta w stylu:

class ClientType{
        virtual float discount()=0;
        virtual int maxCars()=0;
        virtual string introduceYourself()=0;
}

class UberClientType: public ClientType{
        virtual float discount() { return 100.0; }
        virtual int maxCars() { return 100; }
        virtual string introduceYourself() {return "uber klient!"; }
}

class PoorClientType: public ClientType{
        virtual float discount() { return 0.0; }
        virtual int maxCars() { return 0; }
        virtual string introduceYourself() {return "biedny klient!"; }
}

class Client: public ClientType {
    private:
        string name;
        string surname;
        ClientType* clientType;
    public:
        BasicClient(string n, string s, ClientType* ct):name(n),surname(s), clientType(ct) {}
        virtual float discount() { return clientType.discount(); } // delegacja
        virtual int maxCars() { return clientType.maxCars(); } // delegacja
        virtual string introduceYourself() { return clientType.introduceYourself(); } // delegacja
        void changeType(ClientType* newType){ clientType = newType; } // zmiana typu
}

W takim układzie masz klienta i w trakcie tworzenia dajesz mu typ. Typ mozesz zmienić za pomocą metody. I delegujesz wywołania do klasy typu.