Member Function Pointer vs Virtual Function

    I did read Deitel =96 How to program c++ book. I did self-study at
home. I am very curious to see how polymorphism works. It does say =96
switch logic can lead to error prone if programmers are not careful,
but virtual functions are easier to use.
    Please state your opinion. Should you prefer to use member functions
array pointer or switch logic? Virtual function calls require triple
indirection pointer and it requires more execution time like CPU's
overheads.
    F_1(), F_2(), F_3(), and F_4() modify data members of class Test.
You only need to invoke Run(). Run() selects either F_1(), =85 F_4()
through member function array pointer.
    I did read some websites on the google. It does mention =96 member
functions array pointer is very rarely used. It encourages you to use
virtual function instead.
    If you put virtual on F_1(), =85 F_4(), vtable will be built in class
Test. It does not enable polymorphism unless you create four sub-
objects as four derived classes. Each derived class has Run(). They
should be able to invoke either F_1(), =85 F_4().
    Please let me know. Do you recommend to use virtual function or
member function array pointer? Thanks=85

class Test
{
public:

    Test() : select_F(0), reg_data(0)
    {
        cout << "Test()" << endl;
        F_PTR_ARRAY[0] = &Test::F_1;
        F_PTR_ARRAY[1] = &Test::F_2;
        F_PTR_ARRAY[2] = &Test::F_3;
        F_PTR_ARRAY[3] = &Test::F_4;
    }

    ~Test()
    {
        cout << "~Test()" << endl;
    }

    void Run()
    {
        (this->*F_PTR_ARRAY[select_F])();
    }

    void Run_Switch()
    {
        switch(select_F)
        {
        case 0:
            F_1();
            break;

        case 1:
            F_2();
            break;

        case 2:
            F_3();
            break;

        case 3:
            F_4();
            break;
        }

        select_F++;
        select_F &= 3;
    }

    void (Test::*F_PTR)();
    void (Test::*F_PTR_ARRAY[4])();

    void F_1()
    {
        cout << "F_1()" << endl;
        reg_data = 10;
        select_F++;
        select_F &= 3;
    }

    void F_2()
    {
        cout << "F_2()" << endl;
        reg_data = 40;
        select_F++;
        select_F &= 3;
    }

    void F_3()
    {
        cout << "F_3()" << endl;
        reg_data = 100;
        select_F++;
        select_F &= 3;
    }

    void F_4()
    {
        cout << "F_4()" << endl;
        reg_data = 150;
        select_F++;
        select_F &= 3;
    }

    int select_F;
    int reg_data;
};

int main()
{
    Test test;

    test.Run();
    test.Run();
    test.Run();
    test.Run();

// test.Run_Switch();
// test.Run_Switch();
// test.Run_Switch();
// test.Run_Switch();

    system("pause");

    return 0;
}