0

我有一个简单bi_map的双向映射类的工作代码，用于在两个方向上存储关联的键值对。我目前的用法是，NID是某种数字 ID 或枚举，OBJ而是昂贵的不可复制的类对象。

最近，我注意到我也需要bi_map<NID,std::string>,是一个真正应该被复制std::string的便宜。OBJ

概括下面的代码的正确方法是什么，以便用户可以指示某些东西是昂贵的（我想使用指针/引用）还是便宜的（我想按值复制所有内容），以便我可以使用正确的实现？

代码

template<typename NID,typename OBJ>
class bi_map
{
  std::map<NID,OBJ*>        m_nid_2_ptr;
  std::map<OBJ const*,NID>  m_ptr_2_nid;

public:
  void insert( NID nid, OBJ& obj )
  {
    m_nid_2_ptr.insert( std::make_pair( nid, &obj ));
    m_ptr_2_nid.insert( std::make_pair( &obj, nid ));
  }

  NID operator[]( OBJ const& obj ) const
  {
    return m_ptr_2_nid.at( &obj );
  }
  OBJ const& operator[]( NID nid ) const
  {
    return *(m_nid_2_ptr.at( nid ));
  }

  using pairs_cb = std::function<void(NID,OBJ const&)>;
  void pairs( pairs_cb cb ) const
  {
    for( const auto& p : m_nid_2_ptr )
      cb( p.first, *p.second );
  }
  size_t size() const { return m_nid_2_ptr.size(); }
};
4

2 回答 2

5

一般来说，有多种选择，我想，没有一个正确的答案。所以，让我们试着找到适合你的东西。你说你想区分便宜的和昂贵的类型。最重要的设计选择是界面。你可以使用：

1) 将模板专门用于指针，在接口中明确提示您使用的是廉价类型：

bi_map< int, std::string* > bi_map_1; // note * is to flag std::string as cheap
bi_map< int, ExpensiveObject > bi_map_2; // no *, thus using heavy implementation

这是这样实现的：

template< typename NID, typename OBJ >
struct bi_map
{
    // implementation for expensive objects, use OBJ* or std::shared_ptr<OBJ>
};

// specialize of the second parameter is a pointer
template< typename NID, typename OBJ >
struct bi_map< NID, OBJ* >
{
    // implementation for cheap objects, store a copy, i.e., use OBJ
};

当然，如果您发现它更具可读性，您也可以使用&而不是标记类型。*

2）如果您不希望廉价/昂贵的分离出现在界面中，即，如果您愿意

bi_map< int, std::string > bi_map_1; // no *
bi_map< int, ExpensiveObject > bi_map_2; // no *

你需要一些不同的东西。一种解决方案是添加默认模板参数：

template< typename >
struct is_expensive_for_bi_map : std::false_type {};

template< typename IND, typename OBJ, bool = is_expensive_for_bi_map< OBJ >::value >
struct bi_map
{
    // implementation for expensive objects, use OBJ* or std::shared_ptr<OBJ>
};

template< typename NID, typename OBJ >
struct bi_map< NID, OBJ, false >
{
    // implementation for cheap objects, store a copy, i.e., use OBJ
};

对于您认为昂贵的每种类型，您添加

template<>
struct is_expensive_for_bi_map< ExpensiveObject > : std::true_type {};

如果昂贵的应该是默认值，只需颠倒名称并调整其余部分，应该很容易。

于 2013-04-01T19:31:49.617 回答
0

另外一个选项：

template<typename T>
struct notExpensive {
  static const bool value = FALSE;
  typedef T REF;
  static T& ref(T& x) { return x; }
  static T& deref(T& x) { return x; }
};
template<typename T>
struct isExpensive {
  static const bool value = TRUE;
  typedef T* REF;
  static T* ref(T& x) { return &x; }
  static T deref(T* x) { return x; }
};
template<typename T>
struct expensiveP : public notExpensive<T> {};

// List of expensive types:
template<> struct expensiveP<ExpensiveObject> : public isExpensive<T> {};

然后用昂贵的P调用填充BiMap。

于 2013-04-01T23:42:52.060 回答