double key map 的实现

• （1）single key value 的 map 容器，一个位置一个值，对应于一个一维数组（或者向量）

  $$y=f(x)$$

• （2）double key value 的 map 容器，对应于一个二维的矩阵

  $$z=f(x, y)$$

对于 double key 的实现，我们选择<utility> 头文件中的std::pair<size_t, size_t>。

自定义比较用的仿函数

STL map 容器的第三个模板参数为用于比较 value 大小的仿函数（重载了operator() 括号运算符） ，std::pair 类型对象的大小，我们需要自定义相关的用于比较的仿函数

typedef std::pair<size_t, size_t> Pair;

// 对 double key 的相对位置不敏感的比较仿函数，[1, 2] == [2, 1]
class compare_a
{
public:
    bool operator()(const Pair& x, const Pair& y) const
    {
        size_t xmin, xmax, ymin, ymax;
        x.first > x.second ? (xmin = x.second, xmax = x.first) : 
            (xmin = x.first, xmax = x.second);
        if (xmin < ymin) 
            return true;
        else if (xmin == ymin)
        {
            if (xmax < ymax)
                return true;
            return false;
        }
        else 
            return false;
    }
};

// 对 double key 的相对位置敏感的，[1, 2] ≠ [2, 1]
class compare_b
{
public:
    bool operator()(const Pair& x, const Pair& y) const
    {
        if (x.first < y.first)
            return true;
        else if (x.first == y.first)
        {
            if (x.second < y.second)
                return true;
            else
                return false;
        }
        else
            return false;
    }
};

double key map 的实现

template<typename T, typename C>
class DoubleKeyMap
{
public:
    typedef typename std::map<Pair, T, C>::value_type value_type;
    typedef typename std::map<Pair, T, C>::iterator iterator;
    typedef typename std::map<Pair, T, C>::const_iterator const_iterator;

    std::pair<iterator, bool> add_item(size_t i, size_t j, const T& val)
    {
        return _map.insert(std::make_pair(Pair(i, j), val));
    }
    bool contain_key(size_t i, size_t j) const
    {
        auto pos = _map.find(Pair(i, j));
        return pos != _map.end();
    }
    const T& operator()(size_t i, size_t j) const
    {
        assert(contain_key(i, j));
        return _map[Pair(i, j)];
    }
    T& operator()(size_t i, size_t j)
    {
        assert(contain_key(i, j));
        return _map[Pair(i, j)];
    }
    void clear()
    {
        _map.clear();
    }
    iterator begin();
    const_iterator begin() const;
    iterator end();
    const_iterator end() const;


private:
    // 
    std::map<Pair, T, C> _map;
};

typedef DoubleKeyMap<double, compare_a> DoubleMapA;
typedef DoubleKeyMap<double, compare_b> DoubleMapB;