C++ 在boost:：variant上调用函数而不考虑类型？

我有一个类，它有一个模板：

 template<class T = int> class slider;

是否可以像下面的示例中那样执行Process（）函数

    for(auto i = Sliders.begin(); i != Sliders.end(); ++i)
    {
        switch(i->second.which())
        {
            boost::get<???Any???>(i->second)->Process();
        }
    }

for（自动i=Sliders.begin（）；i！=Sliders.end（）；++i）
{
开关（i->second.which（））
{
boost:：get（i->second）->Process（）；
}
}

---

如果是，怎么做？

不，一点也不。你必须访问和处理每一种类型的案件。与你的开关黑客相比，访问者做得更好。

这是不可能的，因为

boost:：variant

无法知道

variant

中的所有类型都有任何共同之处。事实上，由于编译器为使用的每个模板专门化生成一个不同的类，因此对于

boost:：variant

中的每种类型，需要使用的

Process（）

函数的地址都是不同的。为了解决这个问题，您可以放弃variant，使用虚拟函数和多态类共享一个公共基类。

这样的函数会返回什么？不能在运行时更改函数的类型。变量的要点是它的内容是在运行时确定的

它只能返回一个

boost:：any

。这实际上只是把一种未知的东西换成另一种（提醒你，当你不知道它包含什么的时候，这个未知的东西很难处理）。但如果你想看到这样的访客：

struct convert_to_any : public boost::static_visitor<boost::any>
{
  template<typename T> boost::any operator() (const T& t) {return t;}
};

只需使用

apply\u visitor

即可。如果变量包含可与

运算符->

一起使用的类型，并且该函数的返回值可以对其调用

过程，则它将被调用。
（未测试的代码！）

struct CallProcess:static\u visitor
{
样板
void运算符（）（常量T&T）常量
{
t->Process（）；
}
};
对于（自动i=滑块。开始（）；i！=滑块。结束（）；++i）
{
boost:：apply_visitor（CallProcess（），i->second）；
}
这听起来像。你想在这里做什么你想这样做？最重要的是，为什么你不使用访问者？一个例子真的很棒，我从来没有在C++中做过类似基类和用户类的事情：
struct convert_to_any : public boost::static_visitor<boost::any>
{
  template<typename T> boost::any operator() (const T& t) {return t;}
};

struct ProcessVisitor : public boost::static_visitor<>
{
  template<typename T> void operator() (const T& t) const {t->Process();}
};

struct CallProcess : static_visitor<>
{
  template <class T>
  void operator()(const T &t) const
  {
    t->Process();
  }
};

for(auto i = Sliders.begin(); i != Sliders.end(); ++i)
{
  boost::apply_visitor(CallProcess(), i->second);
}