class A {
    std::vector<Method> Methods;
    void DoSomething(int methodNo, Arg1* arg1, Arg2* arg2) {
        (this->*(Methods[methodNo]))(arg1, arg2);
    }
}

class B : public A{
    B() {
        Methods.push_back(&B::Something);
    }

    Something(Arg1* arg1, Arg2* arg2) { }
}

struct Base {};

struct Derived : Base {
  void foo() { std::cout << "Hello World!" << std::endl; }
};

struct DerivedDerived : Derived {
  void foo() { std::cout << "Um..." << std::endl; }
};

struct Derived2 : Base {
  void foo() { std::cout << "Goodbye World!" << std::endl; }
};

struct Independent {
  void foo() { std::cout << "Huh?" << std::endl; }
};

int main()
{
   Derived d;
   DerivedDerived dd;
   Derived2 d2;

   void (Base::*pfoo)() = static_cast<void (Base::*)()>(&Derived::foo);
   // Корректное преобразование, поддерживается `static_cast`

   Base *b = &d;
   (b->*pfoo)();
   // Корректное выражение, корректный вызов `d.foo()`

   (d.*pfoo)();
   // Корректное выражение, корректный вызов `d.foo()`

   b = &dd;
   (b->*pfoo)();
   // Корректное выражение, корректный вызов `dd.Derived::foo()`

   (dd.*pfoo)();
   // Корректное выражение, корректный вызов `dd.Derived::foo()`

   b = &d2;
   (b->*pfoo)();
   // Корректное выражение, некорректный вызов - поведение не определено

   (d2.*pfoo)();
   // Корректное выражение, некорректный вызов - поведение не определено

   Independent i;
   (i.*pfoo)();
   // Некорректное выражение, ошибка компиляции

   pfoo = static_cast<void (Base::*)()>(&Independent::foo);
   // Некорректное преобразование, не поддерживается `static_cast`,
   // ошибка компиляции
}

Methods.push_back(static_cast<Method>(&B::Something));

template <typename T> add_method(T method)
{
  Methods.push_back(static_cast<Method>(method));
}

class B;

class A
{
   using B_Method = void ( B::* )(Arg1 * arg1, Arg2 * arg2);
   std::vector<B_Method> m_methods;
   void DoSomething(int methodNo, Arg1 * arg1, Arg2 * arg2);
};

class B : public A
{
    B(void)
    {
       Methods.push_back(&B::Something);
    }

    void Something(Arg1* arg1, Arg2* arg2) { }
};

void A::DoSomething(int methodNo, Arg1 * arg1, Arg2 * arg2)
{
    (static_cast<B *>(this)->*(m_methods[methodNo]))(arg1, arg2);
}

class B;

typedef void(B::*b_method)(Arg1 *, Arg2 *);

class A
{
    std::vector<b_method> Methods;
    void DoSomething(int methodNo, Arg1* arg1, Arg2* arg2);
}

void B::DoSomething(int methodNo, Arg1* arg1, Arg2* arg2)
{
    if((B *selfPtr = dynamic_cast<B *>(this))) // check for inherit
    {
        (selfPtr->*(m_methods[methodNo]))(arg1, arg2);
    }
}

class B : public A
{
    B()
    {
        Methods.push_back(&B::Something);
    }

    Something(Arg1* arg1, Arg2* arg2) { }
}