Checking for existence in std::map - count vs find

So there seem to be two generally acceptable methods of determining whether or not a key exists in a std::map:

map.find(key) != map.end()
map.count(key) > 0

Is one more efficient than the other? Specifically, the concept of count() could be interpreted to mean that the method will iterate over every key, tallying a total count (and because of the definition of std::map, that total count will always be 0 or 1). Is count() guaranteed to "stop" after a match, operating at the same complexity as a find()?

Since a map can only have at most one key, count will essentially stop after one element has been found. However, in view of more general containers such as multimaps and multisets, find is strictly better if you only care whether some element with this key exists, since it can really stop once the first matching element has been found.

In general, both count and find will use the container-specific lookup methods (tree traversal or hash table lookup), which are always fairly efficient. It's just that count has to continue iterating until the end of the equal-range, whereas find does not. Moreover, your code should document intent, so if you want to find something, use find.

According to the source code, I suggest to use find. See the source code.

In GCC, the code is following (stl_map.h):

    const_iterator
    find(const key_type& __x) const
    { return _M_t.find(__x); }

    size_type                                                                              
    count(const key_type& __x) const                                                       
    { return _M_t.find(__x) == _M_t.end() ? 0 : 1; }  

In Visual Studio on the windows platform, the code are following (xtree):

    const_iterator find(const key_type& _Keyval) const
	{	// find an element in nonmutable sequence that matches _Keyval
 		const_iterator _Where = lower_bound(_Keyval);
    	return (_Where == end()
	    	|| _DEBUG_LT_PRED(this->_Getcomp(),
		    	_Keyval, this->_Key(_Where._Mynode()))
			    	? end() : _Where);
	}

    //....

    const_iterator lower_bound(const key_type& _Keyval) const
	{	// find leftmost node not less than _Keyval in nonmutable tree
	    return (const_iterator(_Lbound(_Keyval), this));
	}

    //....

    _Nodeptr _Lbound(const key_type& _Keyval) const
	{	// find leftmost node not less than _Keyval
        _Nodeptr _Pnode = _Root();
        _Nodeptr _Wherenode = this->_Myhead;	// end() if search fails

        while (!this->_Isnil(_Pnode))
            if (_DEBUG_LT_PRED(this->_Getcomp(), this->_Key(_Pnode), _Keyval))
                _Pnode = this->_Right(_Pnode);	// descend right subtree
            else
                {	// _Pnode not less than _Keyval, remember it
                _Wherenode = _Pnode;
                _Pnode = this->_Left(_Pnode);	// descend left subtree
                }

	    return (_Wherenode);	// return best remembered candidate
	}

    //..........................................
    //..........................................

    size_type count(const key_type& _Keyval) const
    {	// count all elements that match _Keyval
        _Paircc _Ans = equal_range(_Keyval);
        size_type _Num = 0;
        _Distance(_Ans.first, _Ans.second, _Num);
        return (_Num);
    }
    
    //....

    _Pairii equal_range(const key_type& _Keyval) const
    {	// find range equivalent to _Keyval in nonmutable tree
        return (_Eqrange(_Keyval));
    }
    
    //....

    _Paircc _Eqrange(const key_type& _Keyval) const
    {	// find leftmost node not less than _Keyval
        _Nodeptr _Pnode = _Root();
        _Nodeptr _Lonode = this->_Myhead;	// end() if search fails
        _Nodeptr _Hinode = this->_Myhead;	// end() if search fails

        while (!this->_Isnil(_Pnode))
            if (_DEBUG_LT_PRED(this->_Getcomp(), this->_Key(_Pnode), _Keyval))
                _Pnode = this->_Right(_Pnode);	// descend right subtree
            else
                {	// _Pnode not less than _Keyval, remember it
                if (this->_Isnil(_Hinode)
                        && _DEBUG_LT_PRED(this->_Getcomp(), _Keyval,
                        this->_Key(_Pnode)))
                    _Hinode = _Pnode;	// _Pnode greater, remember it
                _Lonode = _Pnode;
                _Pnode = this->_Left(_Pnode);	// descend left subtree
                }

        _Pnode = this->_Isnil(_Hinode) ? _Root()
            : this->_Left(_Hinode);	// continue scan for upper bound
        while (!this->_Isnil(_Pnode))
            if (_DEBUG_LT_PRED(this->_Getcomp(), _Keyval, this->_Key(_Pnode)))
                {	// _Pnode greater than _Keyval, remember it
                _Hinode = _Pnode;
                _Pnode = this->_Left(_Pnode);	// descend left subtree
                }
            else
                _Pnode = this->_Right(_Pnode);	// descend right subtree

        const_iterator _First = const_iterator(_Lonode, this);
        const_iterator _Last = const_iterator(_Hinode, this);
        return (_Paircc(_First, _Last));
	}

If you just want to find whether the key exists or not, and don't care about the value, it is better to use map::count as it returns only an integer. map::find returns an iterator, thus by using count, you will save the construction of an iterator.