Question

是否可以删除以下循环中的分支。所有迭代器都来自容器类型std::map<type_name, T>

  record_iterator beginIter = lastLookup_;                                                                                                                                                                                                                                                                                                                             
  record_iterator endIter = lastLookup_;                                                                                                                                                                                                                                                                                                                               
  ++endIter;                                                                                                                                                                                                                                                                                                                                                           
  for(;endIter != end(); ++beginIter, ++endIter){                                                                                                                                                                                                                                                                                                                      
    time_type now = beginIter->first;                                                                                                                                                                                                                                                                                                                                  
    if(ts == now){                                                                                                                                                                                                                                                                                                                                                     
      lastLookup_ = beginIter;                                                                                                                                                                                                                                                                                                                                         
      return beginIter;                                                                                                                                                                                                                                                                                                                                                
    }else if(ts > now && ts <= endIter->first){                                                                                                                                                                                                                                                                                                                        
      lastLookup_ = beginIter;                                                                                                                                                                                                                                                                                                                                         
      return endIter;
    }
  }

这个算法试图解决的问题是优化正向查找，假定该位置与最后一个查找位置相同或（不太远）前进。理想情况下，我保留了最后查找位置的迭代器，并线性向前移动。但这似乎与

具有相同的表现

  record_iterator it= sliceMap_.find(ts);                                                                                                                                                                                                                                                                                                                              
  if(it !=end()){                                                                                                                                                                                                                                                                                                                                                      
    return it;                                                                                                                                                                                                                                                                                                                                                         
  }else{                                                                                                                                                                                                                                                                                                                                                               
    return sliceMap_.upper_bound(ts);                                                                                                                                                                                                                                                                                                                                  
  }

我觉得问题是分支，所以可以删除此代码中的分支，以便我可以分析不同的速度吗？

Answer 1

第一种方法存在三个大问题：

循环内的比较太多。
在std::map上使用迭代器涉及使用std::map<>::iterator::operator++()，这不是很快。查看从第62行开始的实现：http://gcc.gnu.org/onlinedocs/libstdc++/libstdc++-html-USERS-3.4/tree_8cc-source.html。
在std::map上使用迭代器是线性搜索。在地图上搜索应该是对数的。

您的第二种方法也存在问题。你正在搜索两次。

为什么不使用

return sliceMap_.lower_bound(ts);

这应该通过一次对数搜索完全符合您的要求。

Answer 2

正如有些人所说，第一种方法没有多大意义，因为你在有序容器上进行线性搜索。我意识到该位置应该在 lastLookup

附近

关于第二种方法，我认为简单的优化将消除第二次查找。你在 record_iterator it = sliceMap_.find（ts）; 上做了一个，而另一个在返回sliceMap_.upper_bound（ts）;

EDITED

：
尝试这样做：

record_iterator it = sliceMap_.lower_bound(ts);                                                                                                                                                                                                                                                                                                                              
return it;

我们正在做的是，使用lower_bound（）来查找其键不比ts小的第一个元素（包括upper_bound（）不执行的相等元素。）

在c ++中优化if-else分支的小循环

2 个答案: