Problems with std::map.insert() and std::map.find()

I have written a class template to store manage/raw pointers, I want to
store pointers to an obects, using a key. I find that find() is not
working (after the first insert) - i.e. once the first item is inserted
in the map, any key passed to the find() method will return the first item.

Additionally, once the first item has been stored, no additional items
can be stored - its driving me nuts, and I cant work outt why this is
happening. I have included both my classes (i.e class template and key
class here - hopefully, someone can spot what is causing things to go
awry). To summarize the problem - every - i.e. find() and insert() work
as expected, UNTIL the first item is inserted into the map - which seems
to suggest that somehow, the Keys are considered non-unique???

The code follows below:

PointerMap.h
=============

#pragma once

#include <string>
#include <map>
#include <stdexcept>

template<class T1, class T2>
class PointerMap
{
public:
    typedef typename std::map<T1, T2*>::reference reference;
    typedef typename std::map<T1, T2*>::const_reference const_reference;
    typedef typename std::map<T1, T2*>::const_iterator const_iterator;
    typedef typename std::map<T1, T2*>::iterator iterator;

    PointerMap()
    {
    }

    ~PointerMap()
    {
        clear();
    }

    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(); }
    iterator find(T1 key) { return m_map.find(key) ; }
    const_iterator find(T1 key) const { return m_map.find(key) ; }

    iterator erase(iterator where)
    {
        if(where != m_map.end() && *where)
        {
            T*& ptr = *where;
            delete ptr;
            ptr = 0;
        }

        return m_map.erase(where);
    }

    iterator erase(iterator begin, iterator end)
    {
        while(begin != end)
        {
            T2*& ptr = begin->second ;
            if ( ptr != 0)
            {
                delete ptr ;
                ptr = 0;
            }

            begin++;
        }

        return m_map.erase(begin, end);
    }

    void clear() { erase(begin(), end()); }

    bool empty() const { return m_map.empty(); }
    size_t size() const { return m_map.size(); }

    void insert(T1 key, T2* val)
    {
        m_map.insert(std::pair<T1, T2*>(key, val));
    }

    T2* operator[] (const T1 idx) const
    {
        if (idx > m_map.size())
            throw std::logic_error("Array bounds exceeded");
        else
            return m_map[idx] ;
    }

    T2*& operator[] (const T1 idx)
    {
        if (idx > m_map.size())
            throw std::logic_error("Array bounds exceeded");
        else
        {
            T2*& ptr = m_map[idx] ;
            if (ptr)
            {
                delete ptr ;
                ptr = 0 ;
            }
            return m_map[idx] ;
        }
    }

private:
    PointerMap(const PointerMap& source);
    PointerMap& operator=(const PointerMap& source);

    std::map<T1, T2*> m_map;
};

RepositoryKey.h
================

class RepositoryKey
{
public:
    RepositoryKey(const unsigned char xch, const long ic, const
std::string& syb, const long fq = 0):
        m_xch(xch), m_ic(ic), m_syb(syb), m_fq(fq)
    {
    }

    RepositoryKey(const RepositoryKey& key):
        m_xch(key.m_xch), m_syb(key.m_syb), m_ic(key.m_ic), m_fq(key.m_fq)
    {
    }

    ~RepositoryKey()
    {
    }

    RepositoryKey& operator=(const RepositoryKey& key)
    {
        if (this != &key)
        {
            m_xch = key.m_xch;
            m_syb = key.m_syb;
            m_ic = key.m_ic ;
            m_fq = key.m_fq ;
        }
        return *this;
    }

    bool operator==(const RepositoryKey& key) const
    {
        return ( (m_xch == key.m_xch) && (m_syb == key.m_syb) &&
                 (m_ic == key.m_ic) && ((long)m_fq == (long)key.m_fq) );
    }

    bool operator < (const RepositoryKey& key) const
    {
        return ( (m_xch < key.m_xch) && (m_ic < key.m_ic) && ((long)m_fq <
(long)key.m_fq)
                && (_stricmp(m_syb.c_str(), key.m_syb.c_str()) < 0));
    }

    unsigned char Id() const { return m_xch; }
    long Ic() const { return m_ic; }
    std::string Symbol() const { return m_syb; }
    long Freq() const { return m_fq ; }

private:
    unsigned char m_xch ;
    long m_ic ;
    std::string m_syb ;
    long m_fq;
};