C++ 蟑螂？大量的元素洗牌、内存重新分配、手动排序只是为了快速找到。对未排序向量的简单线性扫描比任何其他方法都要快，最多可达10个元素。测量一下。这很有趣。是的，我知道，我在代码中使用了这个结构。我只是觉得对于一般情况来说，这不是一个非常可扩展的解决方案。@St

---

蟑螂？大量的元素洗牌、内存重新分配、手动排序只是为了快速找到。对未排序向量的简单线性扫描比任何其他方法都要快，最多可达10个元素。测量一下。这很有趣。是的，我知道，我在代码中使用了这个结构。我只是觉得对于一般情况来说，这不是一个非常可扩展的解决方案。@Steve：对向量的范围调用

sort

，它就被排序了。无需手动洗牌或重新分配。即使是这样，人们也会不遗余力地快速找到。@Inverse:我们想要的是“基于范围的”算法。请参阅Alexandrescu的“迭代器必须运行”和Boost.Range。这不需要是

const_iterator

？确切地说，对不起，我从OP的代码中复制粘贴了它，没有重新检查。编辑在这种情况下，应提供一个单独的函数，该函数接受Container&并返回typename Container:：iterator@GMan：有点。我仍然不完全相信他的建议。迭代器似乎更适合某些算法（例如，

find

，返回一个迭代器而不是一个范围是有意义的），因此我想看到的是对这两者的良好支持（当然还有它们之间的平滑互操作性）。标准必须尽可能通用，但代价是有点冗长。您可以随时优化自己的常用用例。

std::vector<int> foo;
std::vector<int>::iterator pos( std::find( foo.begin(), foo.end(), bar );

template<class T>
class foovector : public std::vector<T>
{
public:
    typename std::vector<T>::iterator find( const T& value )
    {
        return std::find( this->begin(), this->end(), value );
    }
};

foovector<int> foo;
foovector<int>::iterator pos( foo.find( bar ) );

map<stuff> m
m[bar] // returns a reference to the element with key bar.

template <typename T>
typename std::vector<T>::const_iterator find( const std::vector<T>& v, const T& value )
 {
     return std::find( v.begin(), v.end(), value );
 }

template <typename Container, typename T>
typename Container::const_iterator find( const Container& c, const T& value )
{
     return std::find( c.begin(), c.end(), value );
}

template <typename Container>
typename Container::iterator find(Container& c,
                                  typename Container::value_type const& v)
{
  return std::find(c.begin(), c.end(), v);
}

template <typename Container>
typename Container::const_iterator find(Container const& c,
                                        typename Container::value_type const& v)
{
  return std::find(c.begin(), c.end(), v);
}