std::mismatch

#include <algorithm>

// So sánh bằng toán tử ==
template <class InputIterator1, class InputIterator2>
std::pair<InputIterator1, InputIterator2>
    mismatch (InputIterator1 first1, InputIterator1 last1,
              InputIterator2 first2);

// Sử dụng hàm vị từ so sánh
template <class InputIterator1, class InputIterator2, class BinaryPredicate>
std::pair<InputIterator1, InputIterator2>
    mismatch (InputIterator1 first1, InputIterator1 last1,
              InputIterator2 first2, BinaryPredicate pred);

So sánh hai phạm vi (range) và tìm vị trí đầu tiên mà các phần tử tương ứng không khớp (khác nhau). Nó trả về một cặp iterators, mỗi iterator trỏ đến phần tử không khớp trong mỗi phạm vi.

Tham số

first1

• Input Iterator trỏ đến phần tử đầu tiên trong phạm vi thứ nhất.

last1

• Input Iterator trỏ đến phần tử ngay sau phần tử cuối cùng trong phạm vi thứ nhất. Phạm vi thứ nhất là [first1, last1).

first2

• Input Iterator trỏ đến phần tử đầu tiên 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ề

• Một std::pair chứa hai iterators:
  • pair.first: Iterator trỏ đến phần tử đầu tiên không khớp trong phạm vi thứ nhất.
  • pair.second: Iterator trỏ đến phần tử đầu tiên không khớp trong phạm vi thứ hai.
• Nếu hai phạm vi khớp hoàn toàn (tất cả các phần tử tương ứng đều khớp) thì:
  • Với phiên bản (1), pair.first sẽ bằng last1 và pair.second trỏ đến vị trí tương ứng trong phạm vi thứ hai.
  • Với phiên bản (2) cũng tương tự, pair.first bằng last1 và pair.second trỏ đến vị trí tương ứng trong phạm vi thứ hai.
• Nếu phạm vi thứ 2 dài hơn phạm vi thứ nhất, pair.first bằng last1 và pair.second bằng vị trí tương ứng của last1 trong phạm vi thứ 2.
• Nếu phạm vi thứ nhất dài hơn phạm vi thứ 2, mismatch() sẽ chạy đến cuối phạm vi thứ 2, không vượt quá phạm vi này.

Đặc điểm

1. Phạm vi thứ hai (first2 đến hết) không nhất thiết phải có cùng độ dài với phạm vi thứ nhất. mismatch() sẽ dừng lại ở cuối phạm vi ngắn hơn.
2. Phạm vi [first1, last1) là "nửa mở", không bao gồm phần tử last1.
3. Phiên bản 1 của mismatch() 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. mismatch() thường được sử dụng để:
   • Xác định xem hai dãy có giống nhau hay không.
   • Tìm vị trí khác biệt đầu tiên giữa hai dãy.
   • So sánh các phiên bản của cùng một dữ liệu để tìm ra những thay đổi.

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> numbers1 = {1, 2, 3, 4, 5};
  std::vector<int> numbers2 = {1, 2, 4, 4, 5};
  std::vector<int> numbers3 = {1, 2, 3, 4, 5};
  std::vector<int> numbers4 = {1, 2, 3};

  // Phiên bản 1: Tìm vị trí không khớp đầu tiên
  auto result1 = std::mismatch(numbers1.begin(), numbers1.end(), numbers2.begin());

  if (result1.first != numbers1.end()) {
    std::cout << "First mismatch between numbers1 and numbers2 at position: "
              << (result1.first - numbers1.begin()) << std::endl;
    std::cout << "Values: " << *result1.first << " and " << *result1.second << std::endl;
  } else {
    std::cout << "numbers1 and numbers2 are identical.\n";
  }

  // Phiên bản 1: Tìm vị trí không khớp đầu tiên, numbers3 == numbers1
  auto result4 = std::mismatch(numbers1.begin(), numbers1.end(), numbers3.begin());

  if (result4.first != numbers1.end()) {
      std::cout << "First mismatch between numbers1 and numbers3 at position: "
                << (result4.first - numbers1.begin()) << std::endl;
      std::cout << "Values: " << *result4.first << " and " << *result4.second << std::endl;
  } else {
      std::cout << "numbers1 and numbers3 are identical. result.first: " << (result4.first - numbers1.begin())
                << ", result.second: " << (result4.second - numbers3.begin()) << std::endl;
  }

  // Phiên bản 1: So sánh numbers1 và numbers4, numbers4 ngắn hơn
  auto result5 = std::mismatch(numbers1.begin(), numbers1.end(), numbers4.begin());
    
  if (result5.first != numbers1.end()){
    std::cout << "First mismatch between numbers1 and numbers4 at position: "
                << (result5.first - numbers1.begin()) << std::endl;
    std::cout << "Values: " << *result5.first << " and " << *result5.second << std::endl;
  } else {
    std::cout << "numbers1 and numbers4 are identical up to the length of numbers4. "
              << "result.first: " << (result5.first - numbers1.begin())
              << ", result.second: " << (result5.second - numbers4.begin()) << std::endl;
  }
    

  std::string str1 = "abcdef";
  std::string str2 = "abCdef";

  // Phiên bản 2: Tìm vị trí không khớp đầu tiên (không phân biệt hoa thường)
  auto result2 = std::mismatch(str1.begin(), str1.end(), str2.begin(), caseInsensitiveCompare);

  if (result2.first != str1.end()) {
    std::cout << "First case-insensitive mismatch between str1 and str2 at position: "
              << (result2.first - str1.begin()) << std::endl;
    std::cout << "Values: " << *result2.first << " and " << *result2.second << std::endl;
  } else {
    std::cout << "str1 and str2 are case-insensitive identical.\n";
  }

  return 0;
}

Các hàm liên quan

find_first_of	Tìm kiếm phần tử đầu tiên trong một phạm vi mà phần tử đó khớp với bất kỳ phần tử nào trong một phạm vi khác
find_end	Tìm kiếm sự xuất hiện cuối cùng của một dãy con trong một phạm vi khác
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
equal	Kiểm tra xem hai phạm vi có bằng nhau hay không