如何验证两个嵌套变体是否共享同一类型

问：

该代码使用嵌套的 s 对消息进行建模：std::variant

class A{};
class B{};
class C{};
class D{};
using CMD1 = std::variant<A, B>;
using CMD2 = std::variant<C, D>;
using CMD = std::variant<cmd1, cmd2>;

为了将消息发送给正确的执行组件，执行组件定义了一个公共节点，其中包含他们想要接收的所有类型的命令：typelist

struct ActorAC {
  using handleable = typelist<A,C>;
};
struct ActorBD {
  using handleable = typelist<B, D>;
};

在运行时，调度程序接收到一个命令 - 类型是封装所有其他子变体的变体，然后它检查命令的具体类型是否在 actor 的 中，如果是，它会将消息发送给 actor：typelist

CMD cmd = get_cmd();
//this is what I'd like to do
if (is_any(get_concrete_type(cmd), actorAC::handleables)){
  // send message to actorAC
}
if (is_any(get_concrete_type(cmd), actorBD::handleables)) {
  //send message to actor BD
}

获取变体的当前成员只能通过 ，所以让我们尝试一下，我们将编写一个函数来检查给定类型是否是变体的具体类型之一：visit

template <typename HandlableType, typename... Types>
constexpr bool is_concrete(std::variant<Types...> v) {
  return std::visit(Overload{
                        [](HandelableType) {
                          /*it's the same Type! finished*/
                          return true;
                        },
                        []<typename... Typesin>(std::variant<Typesin...> vin) {
                          /* we still didn't get to the leaf variants*/
                          return is_in_concrete<HandlableType>(vin);
                        },
                        [](auto) {
                          /* if it is not a variant and also not our type - for sure it's not what we want*/
                          return false;
                        },
                    },
                    v);
}

让我们尝试使用它：

int main(){
  CMD cmd(A());
  //should compile and return true
  return is_concrete<A>(cmd);
}

但是我从 g++-13 收到此错误：

错误：调用“is_concrete”没有匹配函数

注意：候选模板被忽略：无法匹配“std：：variant<Types...>“与”std：：variant<V1， V2> （）（A）“（又名”variant<变体<A、B>、变体<C、D>>（）（A）“）

因此，在编译器的第一次调用不匹配时 - 发生了什么？？main

理想情况下，最终将是：

template<typename... tl>
bool shouldActUpon(CMD cmd) {
  return (is_concrete<tl>(cmd) || ...);
}

以下是完整文件：

#include <variant>

template <typename... Ts> struct Overload : Ts... {
  using Ts::operator()...;
};
template <typename... Ts> Overload(Ts...) -> Overload<Ts...>;

class A {};
class B {};
class C {};
class D {};

using V1 = std::variant<A, B>;
using V2 = std::variant<C, D>;
using V = std::variant<V1, V2>;


template <typename HandlableType, typename... Types>
constexpr bool is_concrete(std::variant<Types...> cmd) {
  return std::visit(Overload{
                        [&](HandlableType) {
                          /*v1 is a variant in the index call recursive*/
                          return true;
                        },
                        [&]<typename... Typesin>(std::variant<Typesin...> vin) {
                          return is_concrete<HandlableType>(vin);
                        },
                        [](auto) {
                          /*v1 is not a variant - both are of the same type,
                           * same index, and leaf*/
                          return true;
                        },
                    },
                    cmd);
}

int main() {
  V cmd(A);
  is_concrete<A>(cmd);
}