사용자 지정 STL 컨테이너

Question

매핑 된 데이터를 입력 된 순서대로 트래버스하는 코드를 작성했습니다.

내가 코딩 솔루션 몇 번이었다 :

감안할 때 키 타입, K, 및 데이터 타입, D, 표준 : :지도 표준 : : 벡터

하나가 무작위로를 원한 데이터 입력을 찾으려면 map.find(K)을 사용하십시오. 항목을 입력 순서대로 통과하려고 할 때 std::vector::iterator (begin(), end()]을 사용하십시오.

이것은 좋았지 만, 연습으로 이걸 'OrderedMap'을 STL 준수 컨테이너로 쓰고 싶었습니다. 나는 또한 (이 토론 벗었) 한 :

template <typename K, typename D> 
class OrderedMap 
{ 
public: 
    typename OrderedMapValue<K,D>& OrderedMap<K,D>::operator[](const K&); 
    // snip... 
}; 

class MyClass 
{ 
public: 
    MyClass(std::string s) : _my_data(s) {} 
private: 
    std::string _my_data; 
}; 

다음 코드는 작동

template <typename K, typename D> 
class OrderedMapValue 
{ 
private: 
    K first_ref; 
    std::map<K,size_t>& m; 
    std::vector<D>& v; 
public: 
    const K& first 
    D& second 
    assignment operator=(const D& data) 
    { 
     std::map<K,size_t>::const_iterator iter = m.find(first_ref); 
     v[iter.second] = data; // error checking of iter stripped 
    } 
}; 

는 또한

가정 : 그러나

OrderedMap<std::string,MyClass*> omap; 
omap["MyKey"] = new MyClass("dummy"); 

,이 코드는하지 않습니다

OrderedMap::iterator iter = omap.find("MyKey"); 
MyClass * obj = iter->second; 
delete obj; 
iter->second = new MyClass("dummy"); 

내가 돈을 가지고 있다고 가정합니다. e 무언가 a) 구조적으로 어리 석거나 b) 불필요하게 복잡하다. 어떻게해야 하는가?

나는 바퀴를 재발 명할 가능성이 크다는 것을 알고 있지만,이 노력은 주로 STL 용기에 대한 지식과 디자인 패턴 및 적절한 사용법을 향상시키는 데 있습니다. 어떤 통찰력 사전에

감사합니다, OrderedMapValue::operator=에서

Answer 1

, 당신은이 :

이 first_ref 무엇

std::map<K,size_t>::const_iterator iter = m.find(first_ref); 

? 코드는 그것을 다른 곳에서 언급하지 않습니다. 그것은 공용 구현 자의 다른 것으로 대체 된 흔적이있는 것처럼 보입니다.

const K& first.

이것이 문제가 될 수 있습니까?

EDIT 의견에서 : 코드는 first_ref가 어디에서나 초기화된다는 것을 보여주지 않습니다. 그래서 내가 말할 수있는 한, m.find(first_ref)에 대한 호출은 OrderedMapValue의 키가 아닌 빈 문자열을 찾고 있습니다.

Answer 2

내가 이것을 테스트하기 위해 지금 컴파일러를 가지고 있지 않기 때문에 오류가있을 수 있지만, 난 당신이 더 같이 할 생각 :

template <typename K, typename D> 
class OrderedMap 
{ 
private: 
     std::map<K,size_t> &m; 
     std::vector<D> &v; 
public: 
    typename pair<K,D> TYPE; 

     TYPE& operator[](const K &k) 
    { 
     return v[ m[ k ]]; 
    } 

    TYPE& operator[](size_t idx) 
    { 
     return v[ idx ]; 
    } 

    pair<iterator,bool> insert(const TYPE& pair) 
    { 
     map<K, size_t>::const_iterator iter; 
     iter = m.find(pair.first); 

     if(iter != m.end()) 
      return make_pair(v[ iter.second], false); 

     m.insert(make_pair(pair->first, v.size())); 
     v.push_back(pair->second); 

     return make_pair( v.last() , inserted); 
    } 

    iterator &begin() 
    { 
     return v.begin(); 
    } 
    // etc 
};