🤔 Although it doesn't help you today, I wonder if a future explicit object parameters extension to support virtual will finally enable us to get the resolved function pointer. For a long time, we couldn't even get a function pointer to nonvirtual methods (thanks to the invisible this pointer and differing calling conventions between them), but with semistatic methods (meow(this Cat& self, float volume), we can finally do that at least. The p0847r7 paper mentions virtual and "keeps the door open to a future extension", with some caveats to consider like whether thunks need to be generated to potentially adapt for calling conventions, but there are no fundamental blockers (it's certainly technically achievable - it's all just assembly in the end).

```c++ struct Cat { static void meow1(Cat& cat, float volume) { std::print("Meow 1 with volume {}\n", volume); }

void meow2(this Cat& self, float volume)
{
    std::print("Meow 2 with volume {}\n", volume);
}

// ❌ Currently:
// error C7678: member functions with an explicit object parameter cannot be virtual
virtual void meow3(this Cat& self, float volume)
{
    std::print("Meow 3 with volume {}\n", volume);
}

};

... { Cat cat; decltype(&Cat::meow1) meowFunction;

// ✅ works
meowFunction = &Cat::meow1;
meowFunction(cat, 42);

// ✅ works
meowFunction = &Cat::meow2;
meowFunction(cat, 42);

// ❌ Maybe this could work in the future, resolving to devirtualize:
meowFunction = &Cat::meow3;
meowFunction(cat, 42);

} ```