stl 在容器中寻找元素
1、std::find、std::find_if、std::find_if_not
描述：
寻找容器中满足判别条件的首个元素
返回范围 [first, last) 中满足特定判别标准的首个元素。
find 搜索等于 value 的元素。
find_if 搜索谓词 p 对其返回 true 的元素。
函数定义：
template< class InputIt, class T >
InputIt find( InputIt first, InputIt last, const T& value );
template< class InputIt, class T >
constexpr InputIt find( InputIt first, InputIt last, const T& value );
template< class InputIt, class UnaryPredicate >
InputIt find_if( InputIt first, InputIt last,
UnaryPredicate p );
template< class InputIt, class UnaryPredicate >
constexpr InputIt find_if( InputIt first, InputIt last,
UnaryPredicate p );
template< class InputIt, class UnaryPredicate >
InputIt find_if_not( InputIt first, InputIt last,
UnaryPredicate q );
template< class InputIt, class UnaryPredicate >
constexpr InputIt find_if_not( InputIt first, InputIt last,
UnaryPredicate q );
参数：
first, last - 要检验的元素范围
value - 要与元素比较的值
policy - 所用的执行策略。细节见执行策略。
p - 若为要求的元素则返回 true 的一元谓词。
q - 若为要求的元素则返回 false 的一元谓词。
返回值：
返回首个满足条件的迭代器，或若找不到这种元素则为 last 。
可能的实现：
template<class InputIt, class T>
InputIt find(InputIt first, InputIt last, const T& value)
{
for (; first != last; ++first) {
if (*first == value) {
return first;
}
}
return last;
}
template<class InputIt, class UnaryPredicate>
InputIt find_if(InputIt first, InputIt last, UnaryPredicate p)
{
for (; first != last; ++first) {
if (p(*first)) {
return first;
}
}
return last;
}
template<class InputIt, class UnaryPredicate>
InputIt find_if_not(InputIt first, InputIt last, UnaryPredicate q)
{
for (; first != last; ++first) {
if (!q(*first)) {
return first;
}
}
return last;
}
示例：
int main()
{
std::vector<double> vecDouble;
vecDouble.push_back(1.11);
vecDouble.push_back(2.22);
vecDouble.push_back(3.33);
auto findIter = std::find(vecDouble.begin(), vecDouble.end(), 3.33);
if (findIter == vecDouble.end())
std::cout << "容器中不存在该元素" << std::endl;
else
std::cout << "该元素存在，" << "值为：" << *findIter << std::endl;//该元素存在，值为：3.33
}
#include #include 2、std::adjacent_find
描述：
寻找容器中相继相等的首个元素。
在范围 [first, last) 中搜索二个相继的相等元素。
用 operator== 比较元素。
用给定的二元谓词 p 比较元素。
函数定义：
template< class ForwardIt >
ForwardIt adjacent_find( ForwardIt first, ForwardIt last );
template< class ForwardIt >
constexpr ForwardIt adjacent_find( ForwardIt first, ForwardIt last );
template< class ForwardIt, class BinaryPredicate>
ForwardIt adjacent_find( ForwardIt first, ForwardIt last, BinaryPredicate p );
template< class ForwardIt, class BinaryPredicate>
constexpr ForwardIt adjacent_find( ForwardIt first, ForwardIt last, BinaryPredicate p );
参数：
first, last - 要检验的元素范围
p - 若元素应被当做相等则返回 true 的二元谓词。
返回值：
返回首对等同元素的首个元素的迭代器，若找不到这种元素，则返回 last 。
可能的实现：
template<class ForwardIt>
ForwardIt adjacent_find(ForwardIt first, ForwardIt last)
{
if (first == last) {
return last;
}
ForwardIt next = first;
++next;
for (; next != last; ++next, ++first) {
if (*first == *next) {
return first;
}
}
return last;
}
template<class ForwardIt, class BinaryPredicate>
ForwardIt adjacent_find(ForwardIt first, ForwardIt last,
BinaryPredicate p)
{
if (first == last) {
return last;
}
ForwardIt next = first;
++next;
for (; next != last; ++next, ++first) {
if (p(*first, *next)) {
return first;
}
}
return last;
}
示例：
int main()
{
std::vector<double> vecDouble;
vecDouble.push_back(1.11);
vecDouble.push_back(2.22);
vecDouble.push_back(2.22);
vecDouble.push_back(3.33);
vecDouble.push_back(4.44);
auto iter = std::adjacent_find(vecDouble.begin(), vecDouble.end());
if (iter == vecDouble.end())
std::cout << "容器中不存在相继相等元素" << std::endl;
else
std::cout << "存在，" << "值为：" << *iter << std::endl;//存在，值为：2.22
//使用lambda表达式指定条件(一般用于自定义元素)
auto iter2 = std::adjacent_find(vecDouble.begin(), vecDouble.end(), [](double dValue1,double dValue2) {
return dValue1 == dValue2; });
if (iter2 == vecDouble.end())
std::cout << "容器中不存在相继相等元素" << std::endl;
else
std::cout << "存在，" << "值为：" << *iter2 << std::endl;//存在，值为：2.22
}
3、std::search
描述：
在容器中寻找子序列首次出现的位置。
搜索范围 [first, last - (s_last - s_first)) 中元素子序列 [s_first, s_last) 的首次出现。
元素用 operator== 比较。
元素用给定的二元谓词 p 比较。
函数定义：
template< class ForwardIt1, class ForwardIt2 >
ForwardIt1 search( ForwardIt1 first, ForwardIt1 last,
ForwardIt2 s_first, ForwardIt2 s_last );
template< class ForwardIt1, class ForwardIt2 >
constexpr ForwardIt1 search( ForwardIt1 first, ForwardIt1 last,
ForwardIt2 s_first, ForwardIt2 s_last );
template< class ForwardIt1, class ForwardIt2, class BinaryPredicate >
ForwardIt1 search( ForwardIt1 first, ForwardIt1 last,
ForwardIt2 s_first, ForwardIt2 s_last, BinaryPredicate p );
template< class ForwardIt1, class ForwardIt2, class BinaryPredicate >
constexpr ForwardIt1 search( ForwardIt1 first, ForwardIt1 last,
ForwardIt2 s_first, ForwardIt2 s_last, BinaryPredicate p );
参数：
first, last - 要检验的元素范围
s_first, s_last - 要搜索的元素范围
p - 若元素应被当做相等则返回 true 的二元谓词。
返回值：
返回范围中 [first, last - (s_last - s_first)) ，首个子序列 [s_first, s_last) 起始的迭代器。若找不到这种子序列，则返回 last 。
可能的实现：
template<class ForwardIt1, class ForwardIt2>
ForwardIt1 search(ForwardIt1 first, ForwardIt1 last,
ForwardIt2 s_first, ForwardIt2 s_last)
{
for (; ; ++first) {
ForwardIt1 it = first;
for (ForwardIt2 s_it = s_first; ; ++it, ++s_it) {
if (s_it == s_last) {
return first;
}
if (it == last) {
return last;
}
if (!(*it == *s_it)) {
break;
}
}
}
}
template<class ForwardIt1, class ForwardIt2, class BinaryPredicate>
ForwardIt1 search(ForwardIt1 first, ForwardIt1 last,
ForwardIt2 s_first, ForwardIt2 s_last,
BinaryPredicate p)
{
for (; ; ++first) {
ForwardIt1 it = first;
for (ForwardIt2 s_it = s_first; ; ++it, ++s_it) {
if (s_it == s_last) {
return first;
}
if (it == last) {
return last;
}
if (!p(*it, *s_it)) {
break;
}
}
}
}
示例：
int main()
{
std::string str1 = "abcdefgabcdefg";
std::string str2 = "abc";
std::string str3 = "efg";
auto iter1 = std::search(str1.begin(), str1.end(), str2.begin(), str2.end());
if (iter1 == str1.end())
std::cout << "不存在此序列" << std::endl;
else
std::cout << "存在" << "，值为" << *iter1 << std::endl;//存在，值为a
auto iter2 = std::search(str1.begin(), str1.end(), str3.begin(), str3.end());
if (iter2 == str1.end())
std::cout << "不存在此序列" << std::endl;
else
std::cout << "存在" << "，值为" << *iter2 << std::endl;//存在，值为e
}
4、std::find_end
描述：
在容器中寻找子序列最后出现的位置。
在范围 [first, last) 中搜索序列 [s_first, s_last) 的最后一次出现。
用 operator== 比较元素。
用给定的二元谓词 p 比较元素。
函数定义：
template< class ForwardIt1, class ForwardIt2 >
ForwardIt1 find_end( ForwardIt1 first, ForwardIt1 last,
ForwardIt2 s_first, ForwardIt2 s_last );
template< class ForwardIt1, class ForwardIt2 >
constexpr ForwardIt1 find_end( ForwardIt1 first, ForwardIt1 last,
ForwardIt2 s_first, ForwardIt2 s_last );
template< class ForwardIt1, class ForwardIt2, class BinaryPredicate >
ForwardIt1 find_end( ForwardIt1 first, ForwardIt1 last,
ForwardIt2 s_first, ForwardIt2 s_last, BinaryPredicate p );
template< class ForwardIt1, class ForwardIt2, class BinaryPredicate >
constexpr ForwardIt1 find_end( ForwardIt1 first, ForwardIt1 last,
ForwardIt2 s_first, ForwardIt2 s_last, BinaryPredicate p );
参数：
first, last - 要检验的元素范围
s_first, s_last - 要搜索的元素范围
p - 若元素应被当做相等则返回 true 的二元谓词。
返回值：
返回范围 [first, last) 中 [s_first, s_last) 最后一次出现的开端的迭代器。若找不到这种序列，则返回 last。
可能的实现：
template<class ForwardIt1, class ForwardIt2>
ForwardIt1 find_end(ForwardIt1 first, ForwardIt1 last,
ForwardIt2 s_first, ForwardIt2 s_last)
{
if (s_first == s_last)
return last;
ForwardIt1 result = last;
while (true) {
ForwardIt1 new_result = std::search(first, last, s_first, s_last);
if (new_result == last) {
break;
} else {
result = new_result;
first = result;
++first;
}
}
return result;
}
template<class ForwardIt1, class ForwardIt2, class BinaryPredicate>
ForwardIt1 find_end(ForwardIt1 first, ForwardIt1 last,
ForwardIt2 s_first, ForwardIt2 s_last,
BinaryPredicate p)
{
if (s_first == s_last)
return last;
ForwardIt1 result = last;
while (true) {
ForwardIt1 new_result = std::search(first, last, s_first, s_last, p);
if (new_result == last) {
break;
} else {
result = new_result;
first = result;
++first;
}
}
return result;
}
示例：
int main()
{
std::string str1 = "abcdefgabcdefg";
std::string str2 = "abc";
std::string str3 = "efg";
auto iter1 = std::find_end(str1.begin(), str1.end(), str2.begin(), str2.end());
if (iter1 == str1.end())
std::cout << "不存在此序列" << std::endl;
else
std::cout << "存在" << "，值为" << *iter1 << std::endl;//存在，值为a
auto iter2 = std::find_end(str1.begin(), str1.end(), str3.begin(), str3.end());
if (iter2 == str1.end())
std::cout << "不存在此序列" << std::endl;
else
std::cout << "存在" << "，值为" << *iter2 << std::endl;//存在，值为e
}
5、std::mismatch
描述：
寻找两个容器出现不同元素的首个位置。
返回来自二个范围：一个以 [first1, last1) 定义而另一个以 [first2,last2) 定义，的首个不匹配对。
用 operator== 比较元素。
用给定的二元谓词 p 比较元素。
函数定义：
template< class InputIt1, class InputIt2 >
std::pair<InputIt1,InputIt2>
mismatch( InputIt1 first1, InputIt1 last1,
InputIt2 first2 );
template< class InputIt1, class InputIt2 >
constexpr std::pair<InputIt1,InputIt2>
mismatch( InputIt1 first1, InputIt1 last1,
InputIt2 first2 );
template< class InputIt1, class InputIt2, class BinaryPredicate >
std::pair<InputIt1,InputIt2>
mismatch( InputIt1 first1, InputIt1 last1,
InputIt2 first2,
BinaryPredicate p );
template< class InputIt1, class InputIt2, class BinaryPredicate >
constexpr std::pair<InputIt1,InputIt2>
mismatch( InputIt1 first1, InputIt1 last1,
InputIt2 first2,
BinaryPredicate p );
template< class InputIt1, class InputIt2 >
std::pair<InputIt1,InputIt2>
mismatch( InputIt1 first1, InputIt1 last1,
InputIt2 first2, InputIt2 last2 );
template< class InputIt1, class InputIt2 >
constexpr std::pair<InputIt1,InputIt2>
mismatch( InputIt1 first1, InputIt1 last1,
InputIt2 first2, InputIt2 last2 );
template< class InputIt1, class InputIt2, class BinaryPredicate >
std::pair<InputIt1,InputIt2>
mismatch( InputIt1 first1, InputIt1 last1,
InputIt2 first2, InputIt2 last2,
BinaryPredicate p );
template< class InputIt1, class InputIt2, class BinaryPredicate >
constexpr std::pair<InputIt1,InputIt2>
mismatch( InputIt1 first1, InputIt1 last1,
InputIt2 first2, InputIt2 last2,
BinaryPredicate p );
参数：
first1, last1 - 第一元素范围
first2, last2 - 第二元素范围
p - 若元素应被当做相等则返回 true 的二元谓词。
返回值：
返回指向首二个不相等元素的迭代器的 std::pair 。
可能的实现：
template<class InputIt1, class InputIt2>
std::pair<InputIt1, InputIt2>
mismatch(InputIt1 first1, InputIt1 last1, InputIt2 first2)
{
while (first1 != last1 && *first1 == *first2) {
++first1, ++first2;
}
return std::make_pair(first1, first2);
}
template<class InputIt1, class InputIt2, class BinaryPredicate>
std::pair<InputIt1, InputIt2>
mismatch(InputIt1 first1, InputIt1 last1, InputIt2 first2, BinaryPredicate p)
{
while (first1 != last1 && p(*first1, *first2)) {
++first1, ++first2;
}
return std::make_pair(first1, first2);
}
template<class InputIt1, class InputIt2>
std::pair<InputIt1, InputIt2>
mismatch(InputIt1 first1, InputIt1 last1, InputIt2 first2, InputIt2 last2)
{
while (first1 != last1 && first2 != last2 && *first1 == *first2) {
++first1, ++first2;
}
return std::make_pair(first1, first2);
}
template<class InputIt1, class InputIt2, class BinaryPredicate>
std::pair<InputIt1, InputIt2>
mismatch(InputIt1 first1, InputIt1 last1, InputIt2 first2, InputIt2 last2, BinaryPredicate p)
{
while (first1 != last1 && first2 != last2 && p(*first1, *first2)) {
++first1, ++first2;
}
return std::make_pair(first1, first2);
}
示例：
int main()
{
std::vector<int> vecInt1 = {
1,2,3,4,5,6};
std::vector<int> vecInt2 = {
1,2,3,5,6};
auto pair = std::mismatch(vecInt1.begin(),vecInt1.end(),vecInt2.begin(),vecInt2.end());
std::cout << "第一个范围首个不同元素：" << *pair.first << std::endl;//第一个范围首个不同元素：4
std::cout << "第二个范围首个不同元素：" << *pair.second << std::endl;//第二个范围首个不同元素：5
}
6、std::find_first_of
描述：
寻找容器中存在另一容器元素的首个位置。
在范围 [first, last) 中搜索范围 [s_first, s_last) 中的任何元素。
用 operator== 比较元素。
用给定的二元谓词 p 比较元素。
函数定义：
template< class ForwardIt1, class ForwardIt2 >
ForwardIt1 find_first_of( ForwardIt1 first, ForwardIt1 last,
ForwardIt2 s_first, ForwardIt2 s_last );
template< class InputIt, class ForwardIt >
InputIt find_first_of( InputIt first, InputIt last,
ForwardIt s_first, ForwardIt s_last );
template< class InputIt, class ForwardIt >
constexpr InputIt find_first_of( InputIt first, InputIt last,
ForwardIt s_first, ForwardIt s_last );
template< class ForwardIt1, class ForwardIt2, class BinaryPredicate >
ForwardIt1 find_first_of( ForwardIt1 first, ForwardIt1 last,
ForwardIt2 s_first, ForwardIt2 s_last, BinaryPredicate p );
template< class InputIt, class ForwardIt, class BinaryPredicate >
InputIt find_first_of( InputIt first, InputIt last,
ForwardIt s_first, ForwardIt s_last, BinaryPredicate p );
template< class InputIt, class ForwardIt, class BinaryPredicate >
constexpr InputIt find_first_of( InputIt first, InputIt last,
ForwardIt s_first, ForwardIt s_last, BinaryPredicate p );
参数：
first, last - 要检验的元素范围
s_first, s_last - 要搜索的元素范围
p - 若元素应被当做相等则返回 true 的二元谓词。
返回值：
返回范围 [first, last) 中等于来自范围 [s_first; s_last) 中一个元素的首个元素。若找不到这种元素，则返回 last 。
可能的实现
template<class InputIt, class ForwardIt>
InputIt find_first_of(InputIt first, InputIt last,
ForwardIt s_first, ForwardIt s_last)
{
for (; first != last; ++first) {
for (ForwardIt it = s_first; it != s_last; ++it) {
if (*first == *it) {
return first;
}
}
}
return last;
}
template<class InputIt, class ForwardIt, class BinaryPredicate>
InputIt find_first_of(InputIt first, InputIt last,
ForwardIt s_first, ForwardIt s_last,
BinaryPredicate p)
{
for (; first != last; ++first) {
for (ForwardIt it = s_first; it != s_last; ++it) {
if (p(*first, *it)) {
return first;
}
}
}
return last;
}
示例：
int main()
{
std::vector<int> vecInt1 = {
1,6,8,11,15,60};
std::vector<int> vecInt2 = {
2,3,5,11,14};
auto iter = std::find_first_of(vecInt1.begin(), vecInt1.end(), vecInt2.begin(), vecInt2.end());
if (iter == vecInt1.end())
std::cout << "不存在相同元素" << std::endl;
else
std::cout << "存在相同元素，元素下标为：" << std::distance(vecInt1.begin(), iter) << std::endl;
//存在相同元素，元素下标为：3
}
7、std::search_n
描述：
在范围 [first, last) 中搜索 count 个等同元素的序列，每个都等于给定的值 value 。
用 operator== 比较元素。
用给定的二元谓词 p 比较元素。
函数定义：
template< class ForwardIt, class Size, class T >
ForwardIt search_n( ForwardIt first, ForwardIt last, Size count, const T& value );
template< class ForwardIt, class Size, class T >
constexpr ForwardIt search_n( ForwardIt first, ForwardIt last, Size count, const T& value );
template< class ForwardIt, class Size, class T, class BinaryPredicate >
ForwardIt search_n( ForwardIt first, ForwardIt last, Size count, const T& value,
BinaryPredicate p );
template< class ForwardIt, class Size, class T, class BinaryPredicate >
constexpr ForwardIt search_n( ForwardIt first, ForwardIt last, Size count, const T& value,
BinaryPredicate p );
参数：
first, last - 要检验的元素范围
count - 要搜索的序列长度
value - 要搜索的元素值
p - 若元素应被当做相等则返回 true 的二元谓词。
返回值：
指向范围 [first, last) 中找到的序列起始的迭代器。若找不到这种序列，则返回 last 。
若 count 为零或负，则返回 first 。
可能的实现：
template<class ForwardIt, class Size, class T>
ForwardIt search_n(ForwardIt first, ForwardIt last,
Size count, const T& value)
{
if (count <= 0) {
return first;
}
for(; first != last; ++first) {
if (!(*first == value)) {
continue;
}
ForwardIt candidate = first;
Size cur_count = 0;
while (true) {
++cur_count;
if (cur_count >= count) {
// 成功
return candidate;
}
++first;
if (first == last) {
// 穷尽列表
return last;
}
if (!(*first == value)) {
// 栏中过少
break;
}
}
}
return last;
}
template<class ForwardIt, class Size, class T, class BinaryPredicate>
ForwardIt search_n(ForwardIt first, ForwardIt last,
Size count, const T& value, BinaryPredicate p)
{
if (count <= 0) {
return first;
}
for(; first != last; ++first) {
if (!p(*first, value)) {
continue;
}
ForwardIt candidate = first;
Size cur_count = 0;
while (true) {
++cur_count;
if (cur_count >= count) {
// 成功
return candidate;
}
++first;
if (first == last) {
// 穷尽列表
return last;
}
if (!p(*first, value)) {
// 栏中过少
break;
}
}
}
return last;
}
示例：
#include