C++ 根据输入类型选择正确的结构方法

我希望有一个模板函数，它接受类型为T的对象，从中选择并运行正确类中的方法。 像这样的,

struct TypeX
{};
struct TypeY
{};

struct X
{
    void Do(TypeX &r){}
};
struct Y
{
    void Do (TypeY & r){}
};  

template<typename T>
void Do(T& r)
{
   // if(T==TypeX) call X::Do(r)    
}

struct TypeX
{};
结构类型
{};
结构X
{
void Do（TypeX&r）{}
};
结构
{
void Do（TypeY&r）{}
};  
模板
无效Do（T&r）
{
//如果（T==TypeX）调用X:：Do（r）
}

我的解决方案是

template<class V, typename T>
void Do(T& r)
{
   V::Do(r);    
}

模板
无效Do（T&r）
{
V：：Do（r）；
}

或

模板
无效Do（B*p、T&r）
{
p->Do（r）；
}

但是它看起来有缺陷，例如 在我的

main.cpp

中，我必须创建一个

B

指针 或者作为

B*p=新X
或
B*p=新Y
而且我根本不喜欢动态分配或在
main
中引入
B
类型。我只希望我的函数接受一个类型为
T
的
TypeX
或
TypeY
的参数，然后它必须将调用相应方法的输入与
X
或
Y
区分开来，我建议您改用动态多态性。您可以通过虚拟函数和继承来实现这一点。首先，定义一个用作抽象类的类
Base
：

X
和
Y
都将从此类
Base
派生。
X
和
Y
都必须实现
Do（）
成员函数，否则无法实例化：

struct X: public Base {
   // define your Do() function member for X
   virtual void Do() override {
      ...
   }
};

struct Y: public Base{
   // define your Do() function member for Y
   virtual void Do() override {
      ...
   }
};

您根本不需要动态分配：

struct X x;
struct Y y;

Base *p = &x //or &y

您只需选择适当的
结构（即
X
或
Y
）根据输入类型进行实例化，然后将该对象的地址分配给指向
Base
的指针，然后调用
do（）
：

Base*p=//Do（）；

正确的
Do（）
成员函数将根据您实例化的对象的类型进行调用：无论是
struct X
还是
struct Y
，因为C++17可以使用
if constexpr
：

template<typename T>
void Do(T& r)
{
   if constexpr (std::is_same_v<T, TypeX>) {
       X::Do(r);
   } else {
       Y::Do(r);
   }
}

模板
无效Do（T&r）
{
如果constexpr（std:：is_same_v）{
X：：Do（r）；
}否则{
Y：：Do（r）；
}
}


在此之前，您可以尝试使用标记分派，但它需要编写更多的代码

struct X x;
struct Y y;

Base *p = &x //or &y

Base *p = // <-- address of struct X or struct Y object
p->Do();

template<typename T>
void Do(T& r)
{
   if constexpr (std::is_same_v<T, TypeX>) {
       X::Do(r);
   } else {
       Y::Do(r);
   }
}