一般从 boost::variant 转换为类型

我有一个typedef boost::variant<int, float, double, long, bool, std::string, boost::posix_time::ptime> variant我用它来在结构中存储不同类型的值。只有一种特定类型会存储在该结构中，但是我有这些结构的向量，我需要遍历它并从变体中获取实际类型。

现在，当我需要转换此变体的类型时，我会这样做：

variant second = mystruct.variant;
                                if (second.which() == 5) //string 
                    {
                        std::string val = boost::get<std::string>(second);
                        modvalue->AddNodeAttribute(key, val);
                    }
                    else if (second.which() == 0) //int
                    {
                        int val = boost::get<int>(second);
                        modvalue->AddNodeAttribute(key, val);
                    }
                    else if (second.which() == 2) //double
                    {
                        double val = boost::get<double>(second);
                        modvalue->AddNodeAttribute(key,val);
                    }
                    else if (second.which() == 1) //float
                    {
                        float val = boost::get<float>(second);
                        modvalue->AddNodeAttribute(key, val);
                    }
                    else if (second.which() == 3) // long
                    {
                        long val = boost::get<long>(second);
                        modvalue->AddNodeAttribute(key, val);
                    }
                    else if (second.which() == 4) // bool
                    {
                        bool val = boost::get<bool>(second);
                        modvalue->AddNodeAttribute(key, val);
                    }
                    else if (second.which() == 6) // posix::time
                    {
                        boost::posix_time::ptime ptm = boost::get<boost::posix_time::ptime>(second);
                        modvalue->AddNodeAttribute(key, ptm);
                    }

我想知道是否有一种更通用的方法可以通过编写一个通用函数来解决此问题，该函数采用变体和类型 T（即返回值）。但当我这样做时，我仍然需要编写类似的一堆 if 语句来解释每种类型的 T。

所以像FromVariant<int>(var);，但我仍然需要为我的变体中的每种类型执行此操作。

所以看来我的通用解决方案并没有减少我的代码，而是增加了它，这显然不是重点。我想知道是否有人有一个更优雅的解决方案来从我的变体中获取各种类型，该变体有点通用，我可以在其中调用一个给出我想要返回的类型的函数？

实际上，更多地查看您的代码，这里有一个不同的选项 - 再次基于使用访问者..

struct add_node_visitor : boost::static_visitor<>
{
  add_node_visitor(<type of modvalue> & node, <type of key> & key) : _node(node), _key(key) {}

  template <typename _Item>
  void operator()(_Item const& item)
  {
    node->AddNodeAttribute(_key, item);
  }  

  <type of modvalue> & _node;
  <type of key> & _key;
}

to use:

boost::apply_visitor (add_node_visitor(modmodvalue, key), mystruct.variant);

只要你的AddNodeAttribute具有所有类型的重载，以上应该有效......