Question

我还在处理重载Sum函数，该函数可以使用矢量/列表或映射。我的矢量/列表版本的sum函数运行正常，我认为我的地图版本代码相当不错，但是当我测试它时，编译器似乎认为我正在尝试调用函数的列表/矢量版本，并抛出一些编译器错误。相关代码如下：

template <typename T>
const double Sum(typename T start_iter, typename T end_iter)
{// code...
}

template <typename T>
const double Sum(map<typename T, double> start_iter, map<typename T, double> end_iter)
{// different code...
}

int main()
{

map<string, double> test_map; // construct empty map

test_map["Line1"] = 10; // add some data
test_map["Line2"] = 15; 

Sum(test_map.begin(),test_map.end()) // this tries to call the list/vector version of sum
}

我如何混淆这些功能？谢谢！

Answer 1

略微替代评论中讨论的内容：

template <typename Vt>
struct getter
{
  Vt operator()(const Vt& v)
  {
    return v;
  }
};

template <typename F, typename G>
struct getter<std::pair<F, G> >
{
  G operator()(const std::pair<F, G>& v)
  {
    return v.second;
  }
};


template <typename Iterator>
int sum(Iterator it, Iterator end)
{
  int r = 0;
  for(; it != end; ++it)
    r += getter<typename Iterator::value_type>()(*it);
  return r;
}

现在sum函数并不关心迭代的内容，只需依靠适当的getter来获取值......

例如：

  std::map<int, int> f;
  f[1] = 3;
  f[2] = 6;
  f[3] = 12;
  f[4] = 24;

  std::vector<int> g;
  g.push_back(4);
  g.push_back(8);
  g.push_back(16);
  g.push_back(32);

  std::cout << sum(f.begin(), f.end()) << std::endl;
  std::cout << sum(g.begin(), g.end()) << std::endl;

Answer 2

好吧，正如前面的评论中所解释的那样，编译器无法推断出作为Sum参数给出的迭代器的容器类型。

但是，可以使用std::map<X,Y>::iterator::value_type是一对值std::pair<XX, YY>的事实。当然，这不会限制Sum到std::map迭代器的所需特化，而是限制返回一对元素的任何容器迭代器（例如。std::vector< std::pair<std::string, double> >。）

如果这不打扰你，或者像std::vector< std::pair<std::string, double> >这样的sthg应该使用相同的专业化，那么以下代码似乎可以为您提供所需的结果：

#include <map>
#include <string>
#include <iostream>
#include <cassert>
#include <boost/utility/enable_if.hpp>
#include <boost/type_traits/remove_reference.hpp>


// a small structure to 
template <class U>
struct is_a_key_pair_it
{
  typedef boost::false_type type;
};

template <class A, class B>
struct is_a_key_pair_it< std::pair<A, B> >
{
  typedef boost::true_type type;
};

// using boost::disable_if to avoid the following code to be instanciated 
// for iterators returning a std::pair
template <typename T>
const double Sum(T start_iter, T end_iter, 
  typename boost::disable_if<
    typename is_a_key_pair_it<
      typename boost::remove_reference<typename T::value_type>::type 
    >::type >::type * dummy = 0)
{
  // code...
  std::cout << "non specialized" << std::endl;
  return 0;
}

// using boost::enable_if to limit the following specializing of Sum
// to iterators returning a std::pair
template <typename T>
const double Sum(T start_iter, T end_iter, 
  typename boost::enable_if<
    typename is_a_key_pair_it<
      typename boost::remove_reference<typename T::value_type>::type 
    >::type >::type * dummy = 0)
{
  // different code...
  std::cout << "specialized" << std::endl;
  return 1;
}




int main()
{
  typedef std::map<std::string, double> map_t;

  // check
  assert(is_a_key_pair_it<map_t::iterator::value_type>::type::value);
  // works also for const_iterators
  assert(is_a_key_pair_it<map_t::const_iterator::value_type>::type::value);

  map_t test_map;
  test_map["Line1"] = 10; // add some data
  test_map["Line2"] = 15; 

  double ret = Sum(test_map.begin(),test_map.end()); 
}

重载求和函数，使列表/向量与地图混淆

2 个答案: