efficiency of map::operator[] and map-insert

Dear all,

item 24 of Scott Meyers (excellent) effective STL book is about the
performance difference of operator[] compared to map insert. In short
he warns about the possible performance loss of operator[] due to an
extra copy.

Our code uses a lot of this constructs and therefore I profiled his
efficient update algorithm with a std::map<int, std::sting>.

I come to the following profile results (Visual Studio 2003 release
builds):

only adds:
operator[] 15.1
Scott 12.5
(+/- 20%)

dominating inserts:
operator[] 26.4
Scott 25.0
(+/- 4%)

Thus my guess will be that indeed only a very heavy object with
dominating adds in a container will make a difference.

code used:
namespace
{
    typedef std::map<int, std::string> Int2StringMap;

    const size_t g_nMax = 100000;
    const size_t g_nTimes = 10;
    //const size_t g_nTimes = 1;
    const std::string g_str1 = _T("Hello");
    const std::string g_str2 = _T("Hello world");

    template <typename MapType, typename KeyType, typename ValueType>
    typename MapType::iterator map_add_or_update(MapType& rMap, const
KeyType& rKey, const ValueType& rValue)
    {
        typename MapType::iterator it = rMap.lower_bound(rKey);
        if (it != rMap.end() && (rMap.key_comp()(rKey, it->first)) ==
false)
        {
            //update
            it->second = rValue;
            return it;
        }
        else
        {
            return rMap.insert(it, MapType::value_type(rKey, rValue));
        }
    }
}

//profiler does not see static fct's
void Prf1aImpl(Int2StringMap* pMap);
void Prf1bImpl(Int2StringMap* pMap);

//----------------------------------------------------------------------------
// Function Prf1
//----------------------------------------------------------------------------
// Description : prf1
//----------------------------------------------------------------------------
void Prf1()
{
    Int2StringMap mp1a;
    Int2StringMap mp1b;

    Prf1aImpl(&mp1a);
    Prf1bImpl(&mp1b);

    _ASSERT(mp1a == mp1b);
}

//----------------------------------------------------------------------------
// Function Prf1aImpl
//----------------------------------------------------------------------------
// Description : use operator[]
//----------------------------------------------------------------------------
void Prf1aImpl(Int2StringMap* pMap)
{
    for (int n = 0; n < g_nTimes; ++n)
    {
        const std::string& cr = ((n % 2 == 0) ? g_str1 : g_str2);

        for (int i = 0; i < g_nMax; ++i)
        {
            (*pMap)[i] = cr;
        }
    }
}

//----------------------------------------------------------------------------
// Function Prf1bImpl
//----------------------------------------------------------------------------
// Description : use Scott Meyers impl.
//----------------------------------------------------------------------------
void Prf1bImpl(Int2StringMap* pMap)
{
    for (int n = 0; n < g_nTimes; ++n)
    {
        const std::string& cr = ((n % 2 == 0) ? g_str1 : g_str2);

        for (int i = 0; i < g_nMax; ++i)
        {
            map_add_or_update(*pMap, i, cr);
        }
    }
}

Wkr me.

      [ See http://www.gotw.ca/resources/clcm.htm for info about ]
      [ comp.lang.c++.moderated. First time posters: Do this! ]