std::find_first_of

#include <algorithm>

// So sánh bằng toán tử ==
template <class ForwardIterator1, class ForwardIterator2>
ForwardIterator1 find_first_of (ForwardIterator1 first1, ForwardIterator1 last1,
                                ForwardIterator2 first2, ForwardIterator2 last2);

// Sử dụng hàm vị từ so sánh
template <class ForwardIterator1, class ForwardIterator2, class BinaryPredicate>
ForwardIterator1 find_first_of (ForwardIterator1 first1, ForwardIterator1 last1,
                                ForwardIterator2 first2, ForwardIterator2 last2,
                                BinaryPredicate pred);                                 

Tìm kiếm phần tử đầu tiên trong một phạm vi (range) mà phần tử đó khớp với bất kỳ phần tử nào trong một phạm vi khác. Nói cách khác, nó tìm vị trí xuất hiện đầu tiên của một trong các phần tử từ phạm vi thứ hai bên trong phạm vi thứ nhất.

Tham số

first1

• Forward Iterator trỏ đến phần tử đầu tiên trong phạm vi thứ nhất (nơi cần tìm kiếm).

last1

• Forward Iterator trỏ đến phần tử ngay sau phần tử cuối cùng trong phạm vi thứ nhất.

first2

• Forward Iterator trỏ đến phần tử đầu tiên trong phạm vi thứ hai (chứa các giá trị cần tìm).

last2

• Forward Iterator trỏ đến phần tử ngay sau phần tử cuối cùng trong phạm vi thứ hai.

pred

• Một hàm vị từ (binary predicate) nhận hai đối số (một phần tử từ phạm vi thứ nhất và một phần tử từ phạm vi thứ hai) và trả về true nếu hai phần tử được coi là khớp, false nếu không. (Phiên bản 2)

Giá trị trả về

• Iterator trỏ đến phần tử đầu tiên trong phạm vi [first1, last1) mà phần tử này bằng với bất kỳ phần tử nào trong phạm vi [first2, last2).
• Nếu không tìm thấy phần tử nào trong phạm vi [first1, last1) khớp với bất kỳ phần tử nào trong phạm vi [first2, last2), hàm trả về last1.

Đặc điểm

1. find_first_of() tìm kiếm sự xuất hiện đầu tiên của bất kỳ phần tử nào từ tập hợp cần tìm.
2. Phạm vi [first1, last1) và [first2, last2) là "nửa mở", không bao gồm phần tử last1 và last2.
3. Phiên bản 1 của find_first_of() sử dụng toán tử == để so sánh các phần tử. Phiên bản 2 cho phép bạn tùy chỉnh cách so sánh bằng hàm vị từ.
4. Forward Iterator cần thiết cho find_first_of() phải hỗ trợ di chuyển một lần (single-pass), nghĩa là bạn chỉ có thể duyệt qua dãy một lần duy nhất.
5. find_first_of() thường được sử dụng để tìm kiếm xem liệu có bất kỳ ký tự nào từ một tập hợp ký tự cho trước xuất hiện trong một chuỗi hay không, hoặc để tìm kiếm sự xuất hiện của bất kỳ giá trị nào từ một tập hợp giá trị trong một dãy số.

Ví dụ

#include <iostream>
#include <vector>
#include <algorithm>
#include <string>

// Hàm vị từ so sánh hai ký tự (không phân biệt hoa thường)
bool caseInsensitiveCompare(char a, char b) {
  return std::tolower(a) == std::tolower(b);
}

int main() {
  std::vector<int> numbers = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
  std::vector<int> targets = {4, 6, 8};

  // Phiên bản 1: Tìm kiếm sự xuất hiện đầu tiên của bất kỳ phần tử nào trong {4, 6, 8}
  std::vector<int>::iterator it = std::find_first_of(numbers.begin(), numbers.end(), targets.begin(), targets.end());

  if (it != numbers.end()) {
    std::cout << "First occurrence of any element in {4, 6, 8} is: " << *it << " at position: " << (it - numbers.begin()) << std::endl;
  } else {
    std::cout << "None of the elements in {4, 6, 8} were found.\n";
  }

  std::string text = "This is a sample string.";
  std::string vowels = "aeiou";

  // Phiên bản 2: Tìm kiếm nguyên âm đầu tiên (không phân biệt hoa thường)
  std::string::iterator it2 = std::find_first_of(text.begin(), text.end(), vowels.begin(), vowels.end(), caseInsensitiveCompare);

  if (it2 != text.end()) {
    std::cout << "First vowel found: " << *it2 << " at position: " << (it2 - text.begin()) << std::endl;
  } else {
    std::cout << "No vowels found.\n";
  }

  return 0;
}

Các hàm liên quan

search	Tìm kiếm sự xuất hiện đầu tiên của một dãy con trong một phạm vi lớn hơn
find	Tìm kiếm phần tử đầu tiên trong một phạm vi có giá trị bằng với một giá trị cho trước
find_if	Tìm kiếm phần tử đầu tiên trong một phạm vi thỏa mãn một điều kiện cụ thể được xác định bởi một hàm vị từ