我需要一个STL算法，它接受一个谓词和一个集合，并返回true，如果集合中仅有一个成员满足谓词，否则返回false。
使用STL算法如何实现这个功能？
例如，使用STL算法代码替换以下内容以表达相同的返回值：
int count = 0;
for( auto itr = c.begin(); itr != c.end(); ++itr ) {
if ( predicate( *itr ) ) {
if ( ++count > 1 ) {
break;
}
}
}
return 1 == count;
std :: count_if 然后将结果与 1 进行比较。auto it = std::find_if(begin,end,predicate);
if (it == end) return false;
++it;
return std::none_of(it,end,predicate);
或者如果您更喜欢紧凑的方式：
auto it = std::find_if(begin,end,predicate);
return (it != end) && std::none_of(std::next(it),end,predicate);
none_of标准算法。std::count_if†来计算并返回是否为1。#include <iostream>
#include <algorithm> // std::count_if
#include <vector> // std::vector
#include <ios> // std::boolalpha
template<class Iterator, class UnaryPredicate>
constexpr bool is_count_one(Iterator begin, const Iterator end, UnaryPredicate pred)
{
return std::count_if(begin, end, pred) == 1;
}
int main()
{
std::vector<int> vec{ 2, 4, 3 };
// true: if only one Odd element present in the container
std::cout << std::boolalpha
<< is_count_one(vec.cbegin(), vec.cend(),
[](const int ele) constexpr noexcept -> bool { return ele & 1; });
return 0;
}
†更新： 但是std::count_if会计算容器中的整个元素，这与问题中给出的算法不符。最好的方法是使用标准算法集合，在@formerlyknownas_463035818的答案中已经提到。
话虽如此，原始问题中的方法也可以与上述最佳标准方法相媲美，当count达到2时就会发生短路。如果有人对于 OP 的方法感兴趣，并想要一个非标准算法模板函数，请看这里。
#include <iostream>
#include <vector> // std::vector
#include <ios> // std::boolalpha
#include <iterator> // std::iterator_traits
template<class Iterator, class UnaryPredicate>
bool is_count_one(Iterator begin, const Iterator end, UnaryPredicate pred)
{
typename std::iterator_traits<Iterator>::difference_type count{ 0 };
for (; begin != end; ++begin) {
if (pred(*begin) && ++count > 1) return false;
}
return count == 1;
}
int main()
{
std::vector<int> vec{ 2, 3, 4, 2 };
// true: if only one Odd element present in the container
std::cout << std::boolalpha
<< is_count_one(vec.cbegin(), vec.cend(),
[](const int ele) constexpr noexcept -> bool { return ele & 1; });
return 0;
}
现在可以通过提供一个额外的参数来进行泛化，这个参数指定需要在容器中找到多少个N元素。
template<typename Iterator>
using diff_type = typename std::iterator_traits<Iterator>::difference_type;
template<class Iterator, class UnaryPredicate>
bool has_exactly_n(Iterator begin, const Iterator end, UnaryPredicate pred, diff_type<Iterator> N = 1)
{
diff_type<Iterator> count{ 0 };
for (; begin != end; ++begin) {
if (pred(*begin) && ++count > N) return false;
}
return count == N;
}
从formerlyknownas_463035818的答案开始，这可以泛化为查看容器是否恰好具有满足谓词的n项。为什么？因为这是C++，直到我们能在编译时阅读电子邮件，我们才会感到满意。
template<typename Iterator, typename Predicate>
bool has_exactly_n(Iterator begin, Iterator end, size_t count, Predicate predicate)
{
if(count == 0)
{
return std::none_of(begin, end, predicate);
}
else
{
auto iter = std::find_if(begin, end, predicate);
return (iter != end) && has_exactly_n(std::next(iter), end, count - 1, predicate);
}
}
n作为编译时的值（模板非类型参数）呢？ - Cody Grayn = 10000，编译器是否会递归生成 10000 个模板，还是现代编译器在模板化步骤中足够聪明以进行尾调用消除？ - Kevinstd::email_client 概念已经被推迟到 C++23。 - Mark Hn都会得到一个新的函数，该函数调用n-1的函数。这导致编译失败。请参见我先前评论中的链接。 - Mark Hn 作为模板参数的想法：我认为相反的情况更为真实：递归实现可以很容易地被编译器展开和内联。因此，在这里最好保持递归实现（将 n 作为函数参数），并让编译器优化/内联递归调用（对于较小的 n）。 - Jarek Cstd::not_fn 反转谓词作为这个问题算法的核心，它通过聚合std::find_if和std::none_of在被接受的答案中优雅地覆盖，并在失败时进行短路。扫描容器以查找一元谓词，并在满足条件时，继续扫描余下的容器来寻找该谓词的取反结果。我还会提到 C++17 中引入的 negator std::not_fn，替代了不太有用的std::not1和std::not2构造。
我们可以使用std::not_fn 来实现与被接受的答案相同的谓词逻辑（std::find_if 条件性跟随 std::none_of），但是语义略有不同，将后者(std::none_of ) 替换为应用于第一步(std::find_if)所使用的一元谓词的取反结果的std::all_of。例如:
// C++17
#include <algorithm> // std::find_if
#include <functional> // std::not_fn
#include <ios> // std::boolalpha
#include <iostream>
#include <iterator> // std::next
#include <vector>
template <class InputIt, class UnaryPredicate>
constexpr bool one_of(InputIt first, InputIt last, UnaryPredicate p) {
auto it = std::find_if(first, last, p);
return (it != last) && std::all_of(std::next(it), last, std::not_fn(p));
}
int main() {
const std::vector<int> v{1, 3, 5, 6, 7};
std::cout << std::boolalpha << "Exactly one even number : "
<< one_of(v.begin(), v.end(), [](const int n) {
return n % 2 == 0;
}); // Exactly one even number : true
}
既然我已经将本答案限定为C++14（及更高版本），我将介绍一种针对静态大小容器的另一种方法（特别是应用于std::array），利用std::index_sequence与参数包展开：
#include <array>
#include <ios> // std::boolalpha
#include <iostream>
#include <utility> // std::(make_)index_sequence
namespace detail {
template <typename Array, typename UnaryPredicate, std::size_t... I>
bool one_of_impl(const Array& arr, const UnaryPredicate& p,
std::index_sequence<I...>) {
bool found = false;
auto keep_searching = [&](const int n){
const bool p_res = found != p(n);
found = found || p_res;
return !found || p_res;
};
return (keep_searching(arr[I]) && ...) && found;
}
} // namespace detail
template <typename T, typename UnaryPredicate, std::size_t N,
typename Indices = std::make_index_sequence<N>>
auto one_of(const std::array<T, N>& arr,
const UnaryPredicate& p) {
return detail::one_of_impl(arr, p, Indices{});
}
int main() {
const std::array<int, 5> a{1, 3, 5, 6, 7};
std::cout << std::boolalpha << "Exactly one even number : "
<< one_of(a, [](const int n) {
return n % 2 == 0;
}); // Exactly one even number : true
}
这种方法也会在早期失败（“发现多个”）时进行短路，但是与上面的方法相比，它将包含更多简单的布尔比较。
然而，请注意，这种方法可能有其缺点，特别是针对具有许多元素的容器输入的优化代码，正如@PeterCordes在下面的评论中指出的那样。引用评论（由于评论不能保证随时间推移而存在）：
仅因为大小是静态的并不意味着使用模板完全展开循环是一个好主意。在生成的汇编代码中，这需要每次迭代都执行一个分支来停止查找，因此这可能就是一个循环分支。CPU擅长运行循环（代码缓存，回路缓冲区）。编译器将根据启发式算法完全展开基于静态大小的循环，但如果
a很大，则可能不会将其回滚。因此，您的第一个one_of实现已经拥有最佳的两个世界，假设使用像gcc或clang或者可能是MSVC这样的普通现代编译器。
std::any_of()函数返回至少有1个元素满足谓词条件，但可能不止一个。而std::any_of()并不会返回恰好只有1个元素满足谓词条件，这正是OP所需要的。 - Remy Lebeau