Finding most efficient method for large switch-case and if-else

I'm learning OOP and I found that you can use polymophism to replace switch-case and if-else. But I still wonder how to do that most efficiently. Here is my manage class for managing info of 5 different class:

class Manage
{
private:
    Human *List[100];
    int iObject_num;
public:
    Manage(){
        iObject_num=0;
    }
    ~Manage(){
        delete List;
    }
    void vInList()
    {
        int choice;
            do
                {
                    Menu(); //the menu has 6 choices
                    fflush(stdin);
                    cin>>choice;
                    switch(choice)
                    {
                    case 1:{
                        List[iObject_num]= new Student;
                        List[iObject_num]->vInPrivate(); // input the protected info of base class
                        List[iObject_num]->vIn();// input the private of each child class
                        iObject_num++;
                        break;}
                    case 2:{
                        List[iObject_num]= new Undergrad;
                        List[iObject_num]->vInPrivate();
                        List[iObject_num]->vIn();
                        iObject_num++;
                        break;}
                    case 3:{
                        List[iObject_num]= new Worker;
                        List[iObject_num]->vInPrivate();
                        List[iObject_num]->vIn();
                        iObject_num++;
                        break;}
                    case 4:{
                        List[iObject_num]= new Actor;
                        List[iObject_num]->vInPrivate();
                        List[iObject_num]->vIn();
                        iObject_num++;
                        break;}
                    case 5:{
                        List[iObject_num]= new Musician;
                        List[iObject_num]->vInPrivate();
                        List[iObject_num]->vIn();
                        iObject_num++;
                        break;}
                    case 0:
                        cout<<"Exiting...\n";
                        break;
                    default:
                        cout<<"Invalid!\n";
                    }
                } while(choice!=0);

    };
    void vOutList(){
        cout<<"Total number of input: "<<iObject_num<<"\n";
        for (int i=0;i<iObject_num;i++)
        {
            List[i]->vOutPrivate();
            List[i]->vOut();
            cout<<"\n";
        }
    }
};

I've been searching for answer but most of them all told the same thing: override the virtual function. I've already do that as you can see, but if there's more than 5 classes, I will have to do switch-case more than 5 times to call each class' function?

You can create factory for example HumanFactory

class HumanFactory
{
public:
virtual Human* createHuman() = 0;
virtual ~HumanFactory() {}
};
class StudentFactory : public HumanFactory
{
public:
Human* createHuman() override { return new Student; }
};

and all the concrete humans can be added to list in

class Manage
{
private:
std::vector<Human*> humans;
std::vector<HumanFactory*> factories;
// register factory 
void registerFactory(HumanFactory* factory)
{
factories.push_back(factory);
}
void vInList()
{
int choice;
do
{
Menu(); // The menu has 6 choices
std::cin >> choice;
if (choice >= 1 && choice <= factories.size())
{
Human* human = factories[choice - 1]->createHuman();
human->vInPrivate();
human->vIn();
humans.push_back(human);
}
else if (choice != 0)
{
std::cout << "Invalid choice!\n";
}
} while (choice != 0);
}
int main()
{
Manage manager;
manager.registerFactory(new StudentFactory());
// Register other factories as needed
manager.vInList();
manager.vOutList();
return 0;
}

I have provided code, not fully finished but I think will give you idea how to replace switch.

In situations like this I prefer to define a map that uses your type as the key and a function (lambda or otherwise) that handles the specific work needed for that type. To pseudocode it:

std::map<int, funct> type_map;
type_map[1] = [*this]() {                         
List[iObject_num]= new Student;
List[iObject_num]->vInPrivate(); // input the protected info of base class
List[iObject_num]->vIn();// input the private of each child class
iObject_num++;
}

Then range check your input (is it in the map), and if so, execute the method.

If all you want is to avoid switch-case, you can use the following approach:

template <typename T, int x>
struct IndexedHumanType {
};
using AllIndexedHumanTypes = std::tuple<
IndexedHumanType<Student, 1>,
IndexedHumanType<Undergrad, 2>,
IndexedHumanType<Worker, 3>,
IndexedHumanType<Actor, 4>,
IndexedHumanType<Musician, 5>
>;
class Manage {
private:
template <typename T, int I, typename... Others>
bool handle(int choice, std::tuple<IndexedHumanType<T, I>, Others...>) {
if (choice == I) {
List[iObject_num] = new T;
List[iObject_num]->vInPrivate();
List[iObject_num]->vIn();
++iObject_num;
return true;
}
if constexpr (sizeof...(Others) == 0) {
return false;
} else {
return handle(choice, std::tuple<Others...>{});
}
}
bool handle(int choice) {
return handle(choice, AllIndexedHumanTypes{});
}
...
};

This is static polymorphism. If you have multiple places with switch-case sequences, you can generalize handle to accept a lambda function, accepting, in turn, IndexedHumanType, and performing whatever work is necessary.

However, the most efficient in terms of runtime solution is switch-case.