Segmentation Fault 11 in while loop dependent on std::map.count() - while-loop

Question

Within the definition of a class template method, the following lambda definition has been included:
//lambda
auto fnd_nxt_free = [&] ()
{
while(m_map.count(it->first))
{
DBG_PRINT("it->first:" << it->first)
DBG_PRINT("m_map.count(it->first):" << m_map.count(it->first))
DBG_PRINT("distance(m_map.begin(), it):" << distance(m_map.begin(),it))
if(it->first == keyEnd)
{
break;
}
++it;
}
return it;
};
The lambda is used to increment the iterator to the map, for the purpose of assignment.
For consecutive assignments to the map following construction, the intended logic of the code is to increment the iterator to the next free key position within the specified range, before insertion of the specific value.
The different values used in this particular test are (0,1,'A'), which corresponds to construction, (0,2,'B') and (0,3,'C'). Note that the range is implied as [keyBegin, keyEnd).
The segmentation fault is encountered for the third insertion inside the lambda fnd_nxt_free. Notice the debug prints highlighted inside the lambda as part of the source code. The corresponding output (for the third insertion) is as shown below:
it->first:0
m_map.count(it->first):1
distance(m_map.begin(), it):0
it->first:1
m_map.count(it->first):1
distance(m_map.begin(), it):1
it->first:1
m_map.count(it->first):1
distance(m_map.begin(), it):2
The output of m_map.count(<key>) is expected to be 0 when the distance of the iterator from m_map.begin() is 2, for the insertion (0,3,'C'). As the debug print output shows, the value of key is printed correctly in the first two cases, but does not increment after that, even though the distance of the iterator from m_map.begin() is shown to be 2.
In the case of the second insertion (0,2,'B') the same logic in the lambda works as expected, and the while() loop exits when the iterator is incremented past the first key position (0), and the only debug print that is output from the lambda is:
it->first:0
m_map.count(it->first):1
distance(m_map.begin(), it):0
Thus in the second case, the as the iterator moves past the first key position, mm_count() returns 0. However, the same logic fails in the case of the second insertion. I can assure that the rest of the processing before the lambda is hit is exactly the same in both the cases.
Can someone point to the flaw?
MWE
#define DBG_PRINT(...) (cout << __VA_ARGS__<< endl);
template<class K, class V>
class interval_map{
friend void IntervalMapTest();
private:
map<K,V> m_map;
private:
bool did_assign;
public:
interval_map(V const&);
public:
void assign(K const& keyBegin, K const& keyEnd, V const& val);
public:
V const& operator [](K const& key) const;
public:
struct comp;
public:
void display(void);
};
template<class K, class V> struct interval_map<K,V>::comp{
bool operator()(pair<K const&,V const&> p, V const& v) const{
return(p.second < v);
}
bool operator()(V const& v, pair<K const&, V const&> p) const{
return(v < p.second);
}
};
template<class K, class V> interval_map<K,V>::interval_map(V const& val){
m_map.insert(m_map.begin(), make_pair(numeric_limits<K>::lowest(), val));
}
template<class K, class V> V const& interval_map<K,V>::operator [] (K const& key) const{
return (--m_map.upper_bound(key))->second;
}
template<class K, class V> void interval_map<K,V>::assign(K const& keyBegin, K const& keyEnd, V const& val){
auto begin = m_map.find(keyBegin);
auto end = m_map.find(keyEnd);
auto p = equal_range(begin,end,val,comp());
auto it = p.first;
//lambda
auto fnd_nxt_free = [&] (){
LINE
while(
m_map.count(it->first)
){
DBG_PRINT("it->first:" << it->first)
DBG_PRINT("m_map.count(it->first):" << m_map.count(it->first))
DBG_PRINT("distance(m_map.begin(), it):" << distance(m_map.begin(), it))
if(it->first == keyEnd){
break;
}
++it;
}
return it;
};
if(it == end)
{
it = m_map.begin();
next(it,keyBegin);
fnd_nxt_free();
if(it->first < keyEnd){
m_map.insert(make_pair(it->first,val));
}
}
else{
if(p.second == end){
auto tmpKey = it->first;
do
{
if(fnd_nxt_free()->first < keyEnd)
{
if( fnd_nxt_free()->first - tmpKey < 2)
{
if(it == end){
break;
}
++it;
continue;
}
else
{
if(it->first < keyEnd){
m_map.insert(make_pair(it->first, val));
}
}
}
}while(it->first < keyEnd);
}
else{
it = p.second;
fnd_nxt_free();
if(it->first < keyEnd){
m_map.insert(make_pair(it->first,val));
}
}
}
}
template<class K, class V> void interval_map<K,V>::display(){
for(auto i : m_map){
cout << i.first;
cout << " ";
cout << i.second;
cout << endl;
}
}
void IntervalMapTest(){
interval_map<unsigned int, char> iMap('A');
iMap.assign(0,2,'B');
iMap.assign(0,3,'C');
iMap.display();
return;
}