带有自定义分配器的std :: unordered_set

Question

Good evening,

RESOLUTION: The issue was coming from the explicit keyword from my allocator ctors.

EDIT: I've been finally able to locate the issue. It's seems to come from the move ctor of unordered_set when it's used with some custom allocator. Still digging.

EDIT: Weird thing is that there is no issue when using my custom allocator and a std::vector.

Why do I get an error message when I try to copy an element from :

typedef std::unordered_set< const CScopeProfiler* > CInternalScopeProfilersSet;

to :

typedef std::unordered_set< const CScopeProfiler*, std::hash< const CScopeProfiler* >, std::equal_to< const CScopeProfiler* >, CAllocator< const CScopeProfiler* > > CScopeProfilersSet;

as follows :

CProfiler::CScopeProfilersSet CProfiler::ScopeProfilersRegistry() const
{
    CScopeProfilersSet kSet;

    kSet.insert( *( m_pkRegister->begin() ) );

    return kSet;
}

The exact error message is given in french, so the approximate translation would be :

Error 1 error C2664: 'std::_Hash<_Traits>::_Hash(const std::_Uhash_compare<_Kty,_Hasher,_Keyeq> &,const GameForge::Core::CAllocator<T> &)' : impossible to convert second parameter of 'std::_Wrap_alloc<_Alloc>' to 'const GameForge::Core::CAllocator<T> &'   c:\program files (x86)\microsoft visual studio 11.0\vc\include\unordered_set    195 1

Note that if I don't put the kSet.insert(), I don't get the error.

The typedefs are done in the scope of CProfiler.

I've been stuck for days now, and it doesn't seem to come from the hasher as one could expect. Any idea is welcome, and sorry if the post isn't properly formed as it's my first post on StackOverflow.

PS : As requested here is the code snippet.

namespace GameForge
{
    namespace Core
    {
        class CAllocationsHistogram;

        // Ensure profiling code isn't profiled.
        class GF_API CProfiler
        {
        public:
            class CScopeRun;

            class GF_API CScopeProfiler
            {
                friend CProfiler;
                friend CScopeRun;

            public:
                CScopeProfiler( const char* pcLabel );
                ~CScopeProfiler();
            };

            class GF_API CScopeRun
            {
                friend CProfiler;

            public:
                CScopeRun( CScopeProfiler& rkScopeProfiler );
                ~CScopeRun();
            };

            typedef std::unordered_set< const CScopeProfiler*,
                                        std::hash< const CScopeProfiler* >,
                                        std::equal_to< const CScopeProfiler* >,
                                        CAllocator< const CScopeProfiler* > > CScopeProfilersSet;

        private:
            typedef std::unordered_set< const CScopeProfiler* > CInternalScopeProfilersSet;

        public:
            CScopeProfilersSet ScopeProfilersRegistry() const;

        protected:
            CProfiler();
            ~CProfiler();

        private:
            CInternalScopeProfilersSet* m_pkRegister;
        };

Answer 1

Because, unfortunately, your two containers are different types. And so, consequently are their iterators. This problem is what SCARY iterators are designed to resolve - when containers should be considered equivalent for iteration purposes, even though their types are distinct. The workaround is either to unify your container types (maybe deriving one from another), or rewrite not to depend on iterator-based algorithms (dereference and copy elements individually).

EDIT: I was able to repro with a simple example, which has nothing to do with the insert() call, but rather the rvalue move ctor of the temporary kSet. With C++11, there are a few new requirements for your custom allocator - particularly the rebind type function. See here for more info.

template<typename T>
struct CAllocator : allocator<T>
{
    CAllocator(){}

    template <class U>
    CAllocator(CAllocator<U> const &) {}

    // This required to ensure custom allocator is propagated in move semantics
    template <class U>
    struct rebind
    {
        typedef CAllocator<U> other;
    };
};

typedef std::unordered_set< const CScopeProfiler*, std::hash< const CScopeProfiler* >, std::equal_to< const CScopeProfiler* >, CAllocator< const CScopeProfiler * > >  CScopeProfilersSet;

CScopeProfilersSet ScopeProfilersRegistry()
{
    CScopeProfilersSet kSet;
    return kSet;
};