struct ca
{
    int a, b;
    ca() : a(0), b(0)
    {
    }
    void func()
    {
        a++;
    }
    typedef void(ca::*proc)();
};
struct cb : ca
{
    int c;
    cb() : c(0)
    {
    }
    void f2()
    {
        b++; c++;
    }
};
static struct routine
{
    const char*    name;
    ca::proc        proc;
} pdata[] = {
    {"f2", (ca::proc)&cb::f2}, // Тут опасный код
    {"func", &ca::func},
};
cb t1;
ca* p = &t1;
(p->*pdata[0].proc)(); // Есть ли какие-то подводные камни в таком вызове?

#include <iostream>
using namespace std;

struct ca
{
    int a, b;
    ca() : a(0), b(0)
    {
    }
    virtual void f2() = 0;
    void func()
    {
        a++;
    }
    typedef void(ca::*proc)();
};
struct cb : ca
{
    int c;
    cb() : c(0)
    {
    }
    void f2() override
    {
        b++; c++;
    }
};

static struct routine
{
    const char*    name;
    ca::proc        proc;
} pdata[] = {
    {"f2", &ca::f2}, 
    {"func", &ca::func},
};
cb t1;
ca* p = &t1;
(p->*pdata[0].proc)();

struct ca
{
    typedef void(ca::*proc)();
    struct command
    {
        const char*    name;
        ca::proc        proc;
    };
    int a, b;
    ca() : a(0), b(0)
    {
    }
};
struct cb : ca
{
    void f1()
    {
        a++; b++;
    }
    void f2()
    {
        a++; b--;
    }
    static command commands[];
};
struct cс : cb
{
    int c;
    void f3()
    {
        b++; c++;
    }
    static command commands[];
};
ca::command cb::commands[] = {
    {"f1", (ca::proc)&f1}, 
    {"f2", (ca::proc)&f2},
};
ca::command cc::commands[] = {
    {"f1", (ca::proc)&f1}, 
    {"f2", (ca::proc)&f2},
    {"f3", (ca::proc)&f3},
};
cc t1;
ca* p = &t1;
(p->*cc::commands[0].proc)();

    {"f2", (ca::proc)&cb::f2}, // Тут опасный код

(p->*pdata[0].proc)(); // Есть ли какие-то подводные камни в таком вызове?

PCH>struct ca
PCH>{
PCH>cc t1;
PCH>ca* p = &t1;
PCH>(p->*cc::commands[0].proc)();
PCH>

#include <cassert>
#include <iostream>
#include <map>
#include <string_view>
 
struct base {
   virtual ~base() = default;
   virtual void invoke(std::string_view) = 0;
};
 
struct der1: base {
   void invoke(std::string_view method) override {
       static std::map<std::string_view, void (der1::*)()> commands = {
           {"f1", &der1::f1},
           {"f2", &der1::f2},
       };
       auto it = commands.find(method);
       assert(it != commands.end());
       (this->*it->second)();
   }
   void f1() {std::cout << "der1::f1" << std::endl;}
   void f2() {std::cout << "der1::f2" << std::endl;}
};

struct der2: base {
    void invoke(std::string_view method) override {
       static std::map<std::string_view, void (der2::*)()> commands = {
           {"f1", &der2::f1},
           {"f2", &der2::f2},
           {"f3", &der2::f3},
       };
       auto it = commands.find(method);
       assert(it != commands.end());
       (this->*it->second)();
   }
   void f1() {std::cout << "der2::f1" << std::endl;}
   void f2() {std::cout << "der2::f2" << std::endl;}
   void f3() {std::cout << "der2::f3" << std::endl;}
};
 
int main() {
    base* b = nullptr;
    der1 d1;
    b = &d1;
    b->invoke("f1");
    der2 d2;
    b = &d2;
    b->invoke("f2");

[](ca* base)
{
    dynamic_cast<cb&>(*base).f2();
}

typedef void (AFX_MSG_CALL CCmdTarget::*AFX_PMSG)(void);

struct ca
{
    struct command
    {
        const char*    name;
        ca::proc        proc;
    };
    int a, b;
    ca() : a(0), b(0)
    {
    }
    virtual void call_by_name( const char *name ) {};
};
struct cb : ca
{
    void f1()
    {
        a++; b++;
    }
    void f2()
    {
        a++; b--;
    }
    virtual void call_by_name( const char *name )
    {
        // В зависимости от name вызвать нужную функцию или call_by_name() из базового класса.
        ...
    }
    static command commands[];
};
struct cс : cb
{
    int c;
    void f3()
    {
        b++; c++;
    }
    virtual void call_by_name( const char *name )
    {
        ...
    }
    static command commands[];
};

ca* p;
p->call_by_name( "f3" );

PCH>    {"f2", (ca::proc)&cb::f2}, // Тут опасный код
PCH>    {"func", &ca::func},

PCH>(p->*pdata[0].proc)(); // Есть ли какие-то подводные камни в таком вызове?

// не будем сейчас про функции-члены, рассмотрим свободные
void foo(base* p);
void bar(derived* p);

// как написать адаптер foo с сигнатурой, как у bar?
void foo_downcasted(derived* p) { foo(p); }  // очевидно! и безо всяких трюков! LSP выполняется

// как написать адаптер bar с сигнатурой, как у foo?
void bar_upcasted(base* p) { bar(somehow_explicitly_cast<derived*>(p)); } // а вот тут LSP нарушен, придётся что-то делать...

struct base {
  void foo();
  static void free_foo(base* p) { p->foo(); }
  void goo();
  static void free_goo(base* p) { p->goo(); }
};

struct derived : base {
  void bar();
  static void free_bar(base* p) { static_cast<derived*>(p)->bar(); }
};

base* p = new derived();
void (*f)(base*) = derived::free_foo;
void (*b)(base*) = derived::free_bar;
// здесь волшебным образом даны гарантии, что f и b вызовутся только при p, являющимся derived (или его субклассом)
f(p);
b(p);

base* q = new base();
void (*F)(base*) = base::free_foo;
void (*G)(base*) = base::free_goo;
// здесь даны гарантии только о субклассе base
F(q);
G(q);

An rvalue of type “pointer to member of B of type cv T,” where B is a class type, can be converted to an rvalue of type “pointer to member of D of type cv T,” where D is a derived class (clause 10) of B. If B is an inaccessible (clause 11), ambiguous (10.2) or virtual (10.1) base class of D, a program that necessitates this conversion is ill-formed.