Menber And Team Class

#include <iostream>
#include <cstring>
using namespace std;

//class MainMenu
class MainMenu {
private:
    int sel;
public:
    int IssueMenu() {
        cout << "---------------[MainMenu]---------------"
            << endl << "1. Add new Mentee" << endl
            << "2. Add new Mentor" << endl << "3. Add new team" << endl
            << "4. Display all Mentee" << endl << "5. Display all Mentor" << endl
            << "6. Display all members." << endl << "7. Display members by team." << endl << endl
            << "9. Clean Screen" << endl << "0. Quit" << endl
            << "----------------------------------------" << endl
            << "Menu >>";
        cin >> sel;
        return sel;
    }
};

//class Team
class Team {
private:
    char _name[10];
public:
    int id = 0;
    char* name;

    //Create default Team 
    Team(int id, char* name) {
        this->id = id;
        this->name = name;
    } 

    //create Team 
    Team() {
        cout << "[Add New Team]" << endl << "- id :";
        cin >> this->id;

        cout << "- name :";
        cin >> _name;
        this->name = _name;
    }
    //delete Team
    ~Team() { delete name; };
};

class TeamManager {
private:
    int index = 0;
    char search_Name[100];
    Team* tList[100];
public:
    //Match Team_ID and Find Team_Name
    char* MatchTeamName(int id) {
        for (int i = 0; i < index; i++)
            if (tList[i]->id == id) return tList[i]->name;
        cout << "No Search Team : Create New Team";
        return nullptr;
    }

    //3. Add New Team 
    void AddNewTeam() {
        tList[index] = new Team();
        index++;
    }
    void DisplayAllTeam() {
        cout << "<<Team List>>" << endl
            << "-----------------------" << endl;
        for (int i = 0; i < index; i++)
            cout << tList[i]->id << "    " << tList[i]->name << endl;
        cout << "-----------------------" << endl;
    }
    //delete TeamManager 
    ~TeamManager() { delete tList; }
};

//class Member
class Member {
private:
    int team_id = 0;
    char _name[10];
    char _team[10];
protected:
    int id;
    char* name;
public:
    Team* team;
    //Check for What object is Mentee
    int isMentor;

    Member(TeamManager* tMgr,int index) {
        cout << "[Add Mentee]" << endl
            << "- id :" << index << endl;
        this->id = index + 1;

        cout << "- name :";
        cin >> _name;
        this->name = _name;

        tMgr->DisplayAllTeam();
        cout << "- team id :";
        cin >> team_id;

        this->team = new Team(team_id, tMgr->MatchTeamName(team_id));
    }
    virtual void ShowAllMentee() const {}
    virtual void ShowAllMentor() const {}
};

//class Mentee 
class Mentee : public Member {
private:
    int age;
    char interest[100];
public:
    //Default Mentee
    //create Mentee
    Mentee(TeamManager* tMgr, int index) : Member(tMgr, index) {
        //Mentor is false , is Mentee
        this->isMentor = 0;

        cout << "- age :";
        cin >> this->age;

        cout << "- interest :";
        cin >> this->interest;
    }

    //Show Mentee
    void ShowAllMentee() const {
        cout << this->id << "    " <<
            this->name << "    " <<
            this->age << "    " <<
            this->team->id << "    " <<
            this->team->name << "    " <<
            this->interest << endl;
    }

    //delete Mentee
    ~Mentee() {};
};

//class Mentor
class Mentor : public Member {
private:
    char* company;
    char _company[10];
public:
    //create Mentor
    Mentor(TeamManager* tMgr, int index) : Member(tMgr, index) {
        //Mentor is true
        this->isMentor = 1;

        cout << "- company :";
        cin >> _company;
        this->company = _company;
    }

    //Show Mentor
    void ShowAllMentor() const {
        cout << this->id << "    " <<
            this->name << "    " <<
            this->team->id << "    " <<
            this->team->name << "    " <<
            this->company << endl;
    }

    //delete Mentor
    ~Mentor() {};
};



//class MemberManager
class MemberManager {
private:
    int index = 0;      //reset index
    Member* mList[100];

public:
    //1. Add new Mentee 
    void AddNewMentee(TeamManager* tMgr) {
        Mentee* mentee = new Mentee(tMgr, index);
        mList[index] = mentee;
        index++;
    }

    //2. Add new Mentor
    void AddNewMentor(TeamManager* tMgr) {
        Mentor* mentor = new Mentor(tMgr, index);
        mList[index] = mentor;
        index++;
    }

    //4. Display All Mentee 
    void DisplayAllMentee() const {
        cout << "----------------------------------------------------------------"  << endl <<
                "id   " << "   name   " << "   age   " << "   team   " << "   interest   " <<
        endl << "----------------------------------------------------------------"  << endl;

            for (int i = 0; i < index; i++)
                if (mList[i]->isMentor == 0) mList[i]->ShowAllMentee();

        cout << "----------------------------------------------------------------" << endl;
    }

    //5. Display All Mentor 
    void DisplayAllMentor() const {
        cout << "----------------------------------------------------------------" << endl <<
                "id   " << "   name   " << "   team   " << "   company   " <<
        endl << "----------------------------------------------------------------" << endl;

        for (int i = 0; i < index; i++)
            if (mList[i]->isMentor == 1) mList[i]->ShowAllMentor();

        cout << "----------------------------------------------------------------" << endl;
    }

    //6. Display All Member
    void DisplayAllMember() {
        cout << "----------------------------------------------------------------" << endl <<
                "id  " << "  name  " << "  age  " << "  team  " << "  comp/intr  " <<
        endl << "----------------------------------------------------------------" << endl;

        for (int i = 0; i < index; i++) {
            if (mList[i]->isMentor == 0) mList[i]->ShowAllMentee();
            else if (mList[i]->isMentor == 1) mList[i]->ShowAllMentor();
            else cout << "isMentor Value Error" << endl;
        }
    }

    //7.Compare Team and Display Searched MemberList 
    void CompareTeam(TeamManager* tMgr) {
        int search_ID;

        if (tMgr == nullptr) {
            cout << "Empty Team" << endl;
            return;
        }

        else {
            tMgr->DisplayAllTeam();
            cout << "[Search Team]" << endl << " - Search ID : ";
            cin >> search_ID;

            cout << "----------------------------------------------------------------" << endl <<
                    "id  " << "  name  " << "  age  " << "  team  " << "  comp/intr  " <<
            endl << "----------------------------------------------------------------" << endl;

            for (int i = 0; i < index; i++)
                if (mList[i]->team->id == search_ID) {
                    cout << "Search Success" << endl;
                    if (mList[i]->isMentor == 0) mList[i]->ShowAllMentee();
                    else if (mList[i]->isMentor == 1) mList[i]->ShowAllMentor();
                }
            cout << "----------------------------------------------------------------" << endl;
            return;
        }
        cout << "Search Failed" << endl; return;
    }

    //delete MemberManager
    ~MemberManager() {
        delete mList;
        cout << "delete success.";
    }
};

//main 
int main(void) {
    MainMenu mc;
    MemberManager mMgr;
    TeamManager tMgr;

    Team* team;
    int menu;

    while (true) {
        menu = mc.IssueMenu();
        switch (menu) {
        case 1:
            mMgr.AddNewMentee(&tMgr);
            break;

        case 2:
            mMgr.AddNewMentor(&tMgr);
            break;

        case 3:
            tMgr.AddNewTeam();
            break;

        case 4:
            mMgr.DisplayAllMentee();
            break;

        case 5:
            mMgr.DisplayAllMentor();
            break;

        case 6:
            mMgr.DisplayAllMember();
            break;

        case 7:
            mMgr.CompareTeam(&tMgr);
            break;
        case 9:
            system("cls");
            break;
        case 0:
            return 0;
            break;
        }
    }
}