C++ 比较函数模板中的VARTYPE和typeid（）.name/typename

我有以下功能模板：

模板
TypeName AssignDefaultIfNull（变量、TypeName和值）{
if（（Variant.vt！=vt_NULL）| |（Variant.vt！=vt_EMPTY））
{
c变异CV=变异；
如果（CV.vt！=TypeName）{}//要使用
std:：variant
实现类似的概念，您可以定义一个访问者，如果请求的类型未存储在变量中，该访问者将返回指定的默认值。使用实例化器函数，您可以绕过显式指定模板参数，并让模板参数推断完成繁重的工作

需要C++17

#include <iostream>
#include <utility>
#include <variant>

// Leave blank incomplete to prevent uninitialized variant from
// compiling.

// struct blank;
struct blank {};

using Variant = std::variant<blank,
                             unsigned int,
                             int,
                             unsigned long,
                             long
                             /* ... */
                             >;


template < typename R >
class DefaultVisitor
{
  R m_r;
public:
  DefaultVisitor(R const& r) : m_r(r) {}

  R operator() (R const& r) { return r; }

  template < typename T >
  R operator() (T const&) { return m_r; }
};


template < typename R >
DefaultVisitor<R> make_default_visitor(R const& r)
{
  return DefaultVisitor<R>(r);
}


int main()
{
  Variant v(long{0});

  Variant w;

  std::cout << std::visit(make_default_visitor(long{12}), v) << '\n'; // 0
  std::cout << std::visit(make_default_visitor(int{17}), v)  << '\n'; // 17
}

#包括
#包括
#包括
//留空不完整，以防止未初始化的变量
//编译。
//结构空白；
结构空白{}；
使用Variant=std:：Variant；
模板
类默认访问者
{
R m_R；
公众：
DefaultVisitor（R const&R）：m_R（R）{}
R运算符（）（R常量&R）{return R；}
模板
R运算符（）（T常量&）{return m_R；}
};
模板
默认访问者创建默认访问者（R const&R）
{
返回访客（r）；
}
int main（）
{
变体v（长{0}）；
变体w；
STD：：不清楚在代码中引用了什么类型的<代码>变体>代码>如果你使用了，你可以做<代码>（STD:HOLDDSAlpple（CV））{…} /C++ >好，但是它是什么类型的？哪个头定义了<代码>变体>代码>和<代码> CCOMFROXUT/COM>？这可能是这个吗？我没有VisualC++，但是你可以试试<代码>（CV.vt！=CComVariant（TypeName{}）.vt{…}
（需要C++11统一初始化语法）。这将创建一个临时的
CComVariant
，它包装
TypeName
的默认初始化值，并检索
.vt
成员。在C++11之前，这可能会起作用：
如果（CV.vt！=CComVariant（（TypeName（））.vt）{…}
谢谢！我还没有试过，如果出现问题，我会尝试问一个新问题。：-）
#include <iostream>
#include <utility>
#include <variant>

// Leave blank incomplete to prevent uninitialized variant from
// compiling.

// struct blank;
struct blank {};

using Variant = std::variant<blank,
                             unsigned int,
                             int,
                             unsigned long,
                             long
                             /* ... */
                             >;


template < typename R >
class DefaultVisitor
{
  R m_r;
public:
  DefaultVisitor(R const& r) : m_r(r) {}

  R operator() (R const& r) { return r; }

  template < typename T >
  R operator() (T const&) { return m_r; }
};


template < typename R >
DefaultVisitor<R> make_default_visitor(R const& r)
{
  return DefaultVisitor<R>(r);
}


int main()
{
  Variant v(long{0});

  Variant w;

  std::cout << std::visit(make_default_visitor(long{12}), v) << '\n'; // 0
  std::cout << std::visit(make_default_visitor(int{17}), v)  << '\n'; // 17
}

#include <iostream>
#include <utility>
#include <boost/variant.hpp>

using Variant = boost::variant<boost::blank,
                               unsigned int,
                               int,
                               unsigned long,
                               long
                               /* ... */
                               >;


template < typename R >
class DefaultVisitor :  boost::static_visitor<R>
{
  R m_r;
public:
  using result_type = R ; // need this to compile in C++11

  DefaultVisitor(R const& r) : m_r(r) {}

  R operator() (R const& r) const { return r; }

  template < typename T >
  R operator() (T const&) const { return m_r; }
};


template < typename R >
DefaultVisitor<R> make_default_visitor(R const& r)
{
  return DefaultVisitor<R>(r);
}


int main()
{
  Variant v(long{0});

  Variant w;

  std::cout << boost::apply_visitor(make_default_visitor(long{12}), v) << '\n'; // 0
  std::cout << boost::apply_visitor(make_default_visitor(int{17}), v) << '\n'; // 17
}