c++ - std::map と boost::ptr_map テンプレートと継承で戻り値がおかしくなる

Question

私が働いている会社では、「RestrictedMap」というクラスを作成しました。これは、通常の std::map と同じインターフェースを提供しますが、[] 演算子を使用することはできません。クラスを快適に操作するために、他のいくつかの機能が提供されています。内部的に、クラスは std::map をラップします。

「RestrictedPointerMap」と呼ばれる、boost::ptr_map に対して同じことを行う同様のクラスを作成しようとしています。このために、テンプレート引数としてラップするマップのタイプを受け入れ、ほとんどの実装を含むRestrictedMapBaseを作成しました。2 つのクラスが派生し、ラップするマップのタイプを指定します。

以前と同じことを行い、std::map をラップするRestrictedMap
新しいもので、boost::ptr_map をラップするRestrictedPointerMapです。

これがコードです。完全を期すためにクラスを単純化していませんが、後で関連する関数に名前を付けます。

RestrictedMap.h

    #pragma once

    #include <boost/ptr_container/ptr_map.hpp>
    #include <boost/static_assert.hpp>
    #include <boost/assign/list_of.hpp>
    #include <boost/foreach.hpp>
    #include <map>

    /**
    * Class that has the benefits of a map, but does not add an entry if it does not exists. 
    * Do not use RestrictedMapBase directly but use one of the derived classes (RestrictedMap or RestrictedPointerMap).
    */
    template <typename MAP>
    class RestrictedMapBase
    {
    public:
       RestrictedMapBase(const MAP& map): 
          m_map(map)
       {}

       template<class InputIterator>
       RestrictedMapBase(InputIterator first, InputIterator last): 
          m_map(first, last)
       {}

       RestrictedMapBase()
       {}

       /************************************************************************/
       /* std::map interface                                                   */
       /************************************************************************/

       typedef typename MAP::iterator iterator;
       typedef typename MAP::const_iterator const_iterator;
       typedef typename MAP::value_type value_type;
       typedef typename MAP::key_type key_type;
       typedef typename MAP::mapped_type mapped_type;
       typedef typename MAP::size_type size_type;

       iterator begin() { return m_map.begin(); }
       iterator end() { return m_map.end(); }
       const_iterator begin() const { return m_map.begin(); }
       const_iterator end() const { return m_map.end(); }
       bool empty() const { return m_map.empty(); }
       size_type size() const { return m_map.size(); }
       iterator find(const key_type& key) { return m_map.find(key); } 
       const_iterator find(const key_type& key) const { return m_map.find(key); }
       void clear() { m_map.clear(); }
       void erase(iterator where) { m_map.erase(where); }

       bool operator==(const typename RestrictedMapBase<MAP>& other) const { return m_map == other.m_map; }
       bool operator!=(const typename RestrictedMapBase<MAP>& other) const { return m_map != other.m_map; }
       bool operator<(const typename RestrictedMapBase<MAP>& other) const { return m_map < other.m_map; }

       /************************************************************************/
       /* extra                                                                */
       /************************************************************************/

       void erase(const key_type& key)
       {
          iterator iter(find(key));
          assert(found(iter));
          erase(iter);
       }

       void eraseIfExists(const key_type& key)
       {
          m_map.erase(key);
       }

       bool exists(const key_type& key) const
       {
          return found(find(key));
       }

       mapped_type& getValue(const key_type& key)
       {
          return const_cast<mapped_type&>(static_cast<const RestrictedMapBase<MAP>&> (*this).getValue(key));
       }

       const mapped_type& getValue(const key_type& key) const
       {
          const_iterator iter(find(key));
          assert(found(iter));
          return getData(iter);
       }

       mapped_type getValueIfExists(const key_type& key) const
       {
          BOOST_STATIC_ASSERT(boost::is_pointer<mapped_type>::value);
          const_iterator iter(find(key));
          if (found(iter)) {
             return getData(iter);
          } else {
             return 0;
          }
       }

       void setValue(const key_type& key, const mapped_type& value)
       {
          iterator iter(find(key));
          assert(found(iter));
          setData(iter, value);
       }

       void add(const key_type& key, const mapped_type& value)
       {
          assert(!exists(key));
          insert(key, value);
       }

       void add(const RestrictedMapBase<MAP>& mapToAdd)
       {
          BOOST_FOREACH(value_type element, mapToAdd.m_map)
          {
             add(element.first, element.second);
          }
       }

       void addOrReplace(const key_type& key, const mapped_type& value)
       {
          iterator iter(find(key));
          if (found(iter)) {
             setData(iter, value);
          } else {
             insert(key, value);
          }
       }

       mapped_type* addDefaultConstructed(const key_type& key)
       {
          assert(!exists(key));
          return &m_map[key];
       }

    private:
       bool found(const const_iterator& iter) const 
       {
          return iter != end();
       }

       const mapped_type& getData(const const_iterator& iter) const
       {
          return const_cast<const mapped_type&>(iter->second);
       }

       mapped_type& getData(const iterator& iter)
       {
          return const_cast<mapped_type&>(static_cast<const RestrictedMapBase<MAP>&>(*this).getData(iter));
       }

       void setData(const iterator& iter, const mapped_type& value)
       {
          getData(iter) = value;
       }

       virtual void insert(const key_type& key, const mapped_type& value) = 0;

    protected:
       MAP& getMap()
       {
          return m_map;
       }

    private:
       MAP m_map;
    };

    template <typename KEYTYPE, typename DATATYPE>
    class RestrictedMap: public RestrictedMapBase<std::map<KEYTYPE, DATATYPE> >
    {
    public:
       RestrictedMap(const std::map<typename KEYTYPE, typename DATATYPE>& map): RestrictedMapBase(map)
       {}

       template<class InputIterator>
       RestrictedMap(InputIterator first, InputIterator last): RestrictedMapBase(first, last)
       {}

       RestrictedMap()
       {}

       virtual void insert(const KEYTYPE& key, const DATATYPE& value)
       {
          getMap().insert(std::make_pair(key, value));
       }
    };

    template <typename KEYTYPE, typename DATATYPE>
    class RestrictedPointerMap: public RestrictedMapBase<boost::ptr_map<KEYTYPE, DATATYPE> >
    {
    public:
       RestrictedPointerMap(const boost::ptr_map<typename KEYTYPE, typename DATATYPE>& map): RestrictedMapBase(map)
       {}

       template<class InputIterator>
       RestrictedPointerMap(InputIterator first, InputIterator last): RestrictedMapBase(first, last)
       {}

       RestrictedPointerMap()
       {}

       virtual void insert(const KEYTYPE& key, DATATYPE* const& value)
       {
          /* boost::ptr_map::mapped_type does not equal the DATATYPE template parameter passed to it. Therefore this 
           * functions signature *looks* different from the RestrictedMapBase::insert signature */
          getMap().insert(key, std::auto_ptr<DATATYPE>(value));
       }
    };

これは、RestrictedPointerMap でgetValueを呼び出したい場合を除いて、ほとんどの場合機能します。関数getDataは正しい値を返しますが、その後getValue関数で問題が発生します。間違ったポインターを返します (ポインターが間違っているように)。

問題を再現するコードを次に示します。

TestClass.h

    #pragma once

    class SomeClass
    {
    public:
       SomeClass();
       virtual ~SomeClass();
    };

TestClass.cpp

    #include "stdafx.h"
    #include "TestClass.h"
    #include <iostream>

    SomeClass::SomeClass()
    {
       std::cout << "TestClass[" << this << "] created." << std::endl;
    }

    SomeClass::~SomeClass()
    {
       std::cout << "TestClass[" << this << "] deleted." << std::endl;
    }

TestRestrictedPtrMap.cpp (メイン)

    #include "stdafx.h"

    #include "RestrictedMap.h"
    #include "TestClass.h"
    #include <boost/foreach.hpp>

    int _tmain(int argc, _TCHAR* argv[])
    {
       typedef RestrictedPointerMap<int, SomeClass> MapType;
       MapType theMap;
       theMap.add(1, new SomeClass());
       theMap.add(2, new SomeClass());

       BOOST_FOREACH(MapType::value_type mapEntry, theMap) {
          std::cout << mapEntry.first << " = " << mapEntry.second << std::endl;
       }

       SomeClass* oneClass = theMap.getValue(1);
       std::cout << oneClass << std::endl;
       SomeClass* twoClass = theMap.getValue(2);
       std::cout << twoClass << std::endl;

       std::cin.get();
        return 0;
    }

これの出力は次のとおりです。

    TestClass[0078A318] created.
    TestClass[0078A448] created.
    1 = 0078A318
    2 = 0078A448
    0018FBD4
    0018FBD4
    TestClass[0078A318] deleted.
    TestClass[0078A448] deleted.

なぜそれがうまくいかないのか、私にはわかりません。私の知る限り、戻り値は魔法によって悪くなります。

助けてくれてありがとう、

トム

score 2 · Accepted Answer

あなたはぶら下がっている参照を持っています。

aを逆参照すると、実際の基になるイテレータ（a ）から初期化されたものがboost::ptr_map<Key, T>::iteratorオンザフライで構築されます。これは、から返された（または）がローカル一時のメンバー（のメンバー）を参照していることを意味します。boost::ptr_container_detail::ref_pair<Key, T *>std::map<Key, void *>::iteratorT *&const T *&getDataseconditer->second

   const mapped_type& getData(const const_iterator& iter) const
   {
      return const_cast<const mapped_type&>(iter->second); // reference to a temporary
   }
                                            ^^^^^^ *iter is a temporary value

これは、マップのバイナリツリー内のノードの値サブオブジェクトへの参照を提供する通常std::mapのとは異なります。*iter

参照する実際のT *オブジェクトがメモリ内のどこにも存在しないため、インターフェイスを大幅に変更せずに簡単な解決策はありません。の署名を変更して、マップされた値を値ポインターまたは直接参照によってRestrictedPointerMap返す方がよい場合があります。T

T *getValue(const key_type& key);               // not T *&
const T *getValue(const key_type& key) const;   // not const T *const &
// or
T &getValue(const key_type& key);               // not T *&
const T &getValue(const key_type& key) const;   // not const T *const &

c++ - std::map と boost::ptr_map テンプレートと継承で戻り値がおかしくなる

1 に答える 1

Related

Reference