我有一堆 boost::property_map s 定义图中边遍历的成本。我正在执行这些 map 的不同加权组合的算法，目前通过手动执行 totalcost = weight1*weight1_factor + weight2*weight2_factor + ... .虽然属性图的数量在增加，但要像这样总结它们变得很麻烦。

因此，我设想创建一个聚合类，其中包含某种所有 map 的集合。但是，它们的模板不同，如 boost::property_map<Graph, PropertyTag> , 其中PropertyTag map 之间有所不同。因为他们都支持operator[](edge_escriptor) , 我可以使用一些技巧，还是我注定要使用 boost::any ？

最佳答案

我建议您创建一个 boost::tuple具有属性映射和因子。

鉴于在您的上下文中，您有每个 i 的 (propertymap_i, weight_i)，创建一个聚合类，它使用此元组(作为聚合类的模板参数)在被询问时计算所需的值。

您可以使用 operator[] 或属性映射提供的 get() 函数。

如果需要，我可能会更清楚，但它必须稍等一下。

编辑:这是否接近您的需要？

#include <boost/graph/adjacency_list.hpp>
#include <iostream>
#include <boost/shared_ptr.hpp>

namespace property_aggregator
{
  template<typename Tuple, typename T>
  struct helper
  {
      double operator()(Tuple const& tuple, T t)
      {
          return boost::get<0>(tuple)*get(boost::get<1>(tuple), t) +
              helper<typename Tuple::tail_type::tail_type, T>()(tuple.get_tail().get_tail(), t);
      }
  };

  template<typename T>
  struct helper<boost::tuples::null_type, T>
  {
      double operator()(boost::tuples::null_type const& tuple, T t)
      {
          return 0.;
      }
  };

  template<typename T>
  class BasePropertyAggregator
  {
  public:
    virtual double compute( T t ) = 0;
  };

  template <typename PropertyTuple, typename T> 
  class PropertyAggregator : public BasePropertyAggregator<T>
  {
  public:
      PropertyAggregator(PropertyTuple const& tuple) : m_tuple(tuple){}
      virtual ~PropertyAggregator(){}

      double compute( T t )
      {
          return property_aggregator::helper<PropertyTuple, T>()(m_tuple, t);
      }


  private:
      PropertyTuple m_tuple;

  };
}

template<typename T>
class PropertyAggregator
{
public:
    template<typename Tuple>
    PropertyAggregator(Tuple const& tuple) : m_computer(new property_aggregator::PropertyAggregator<Tuple, T>(tuple))
    {}

    double operator()(T t)
    {
      return m_computer->compute(t);
    }

private:
  boost::shared_ptr<property_aggregator::BasePropertyAggregator<T> > m_computer;
};

// Defaut type of a graph
typedef boost::adjacency_list<boost::listS, boost::vecS, boost::directedS,
  boost::property<boost::vertex_index_t, unsigned int>,
  boost::property<boost::edge_weight_t, double,
     boost::property<boost::edge_color_t, double> > > Graph;

int main()
{
    typedef boost::property_map<Graph, boost::edge_weight_t>::type PM1;
    typedef boost::property_map<Graph, boost::edge_color_t>::type PM2;
    typedef boost::graph_traits<Graph>::edge_descriptor EdgeType;

    Graph g;
    PM1 pm1 = get(boost::edge_weight, g);
    PM2 pm2 = get(boost::edge_color, g);

    add_vertex(g);
    add_vertex(g);
    EdgeType edge1 = boost::add_edge(0, 1, g).first;
    put(pm1, edge1, 1.);
    put(pm2, edge1, 2.);

    typedef PropertyAggregator<EdgeType> ComboType;
    ComboType combo1(boost::make_tuple(1., pm1));
    ComboType combo2(boost::make_tuple(1., pm2));
    ComboType combo3(boost::make_tuple(1., pm1, 2., pm2));
    std::cout << "-- " << combo1(edge1) << std::endl;
    std::cout << "-- " << combo2(edge1) << std::endl;
    std::cout << "-- " << combo3(edge1) << std::endl;

    return 0;
}

关于c++ - 模板异构类型的集合，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/7192596/