继承带有模板化类的Boost MultiIndex

Question

我正在尝试复制功能性的Java的LinkedHashMap和Boost的MultiIndex库看起来非常合适。

通过复制文档的mutable_pair：

示例

template<typename T1, typename T2>                                              
struct mutable_pair                                                             
{                                                                               
    typedef T1 first_type;                                                      
    typedef T2 second_type;                                                     

    mutable_pair() :                                                            
        first(T1()), second(T2()) { }                                           
    mutable_pair(const T1 &f, const T2 &s) :                                    
        first(f), second(s) { }                                                 
    mutable_pair(const std::pair<T1, T2> &p) :                                  
        first(p.first), second(p.second) { }                                    

    T1 first;                                                                   
    mutable T2 second;                                                          
};

并覆盖[]运算符（通过派生自multi_index_container）我可以为特定对创建LinkedHashMap，如下所示：

class LinkedHashMap : public multi_index_container<mutable_pair<string, int>,
                        indexed_by<                                             
                            sequenced<>,                                        
                            hashed_unique<                                      
                                member<                                         
                                    mutable_pair<string, int>,                  
                                    string,                                     
                                    &mutable_pair<string, int>::first>          
                                >                                               
                            >                                                   
                        >                                                       
{                                                                               
    public:                                                                     
        int & operator[](const string &k)                                       
        {                                                                       
            nth_index<1>::type::iterator it;                                    

            it = get<1>().find(k);                                              
            if (it == get<1>().end())                                           
            {                                                                   
                push_back(mutable_pair<string, int>(k, 0));                     
                it = get<1>().find(k);                                          
            }                                                                   

            return it->second;                                                  
        }                                                                       
}; 

LinkedHashMap map;
map["Foo"] = 1;
map["Bar"] = 2;
map["Foo"] = 3;
map["Baz"] = 4;
// Results in { Foo = 3, Bar = 2, Baz = 4 }

当我想创建一个模板化的LinkedHashMap时会出现问题：

template<typename Key, typename Value>                                          
class LinkedHashMap : public multi_index_container<mutable_pair<Key, Value>,    
                        indexed_by<                                             
                            sequenced<>,                                        
                            hashed_unique<                                      
                                member<                                         
                                    mutable_pair<Key, Value>,                   
                                    Key,                                        
                                    &mutable_pair<Key, Value>::first>           
                                >                                               
                            >                                                   
                        >                                                       
{                                                                               
    public:                                                                     
        Value & operator[](const Key &k)                                        
        {                                                                       
            nth_index<1>::type::iterator it;                                    

            it = get<1>().find(k);                                              
            if (it == get<1>().end())                                           
            {                                                                   
                push_back(mutable_pair<Key, Value>(k, Value()));                
                it = get<1>().find(k);                                          
            }                                                                   

            return it->second;                                                  
        }                                                                       
};  

LinkedHashMap<string, int> map;
map["Foo"] = 1;
map["Bar"] = 2;
map["Foo"] = 3;
map["Baz"] = 4;

这将无法编译，抱怨operator[]覆盖的第一行; nth_index<1>需要另一个模板参数。如果我给它nth_index<LinkedHashMap<Key, Value>, 1>，它需要type的模板参数。

如果我用nth_index_iterator替换它，我最终可以获得迭代器声明来编译，这被标记为已弃用。但是get<1>()据说不存在，除非我通过this调用它，然后类型不匹配。

我显然很迷失在这里，是否有人能够准确指出我天真的谎言？