Toán tử quan hệ

#include <unordered_map>

// Với a và b là hai unordered_multimap cùng kiểu:
template <class Key, class T, class Hash, class Pred, class Alloc>
bool operator==(const unordered_multimap<Key, T, Hash, Pred, Alloc>& a,
                const unordered_multimap<Key, T, Hash, Pred, Alloc>& b);

template <class Key, class T, class Hash, class Pred, class Alloc>
bool operator!=(const unordered_multimap<Key, T, Hash, Pred, Alloc>& a,
                const unordered_multimap<Key, T, Hash, Pred, Alloc>& b);

So sánh hai std::unordered_multimap với nhau.

Tham số

a, b

• Hai std::unordered_multimap cần so sánh. Chúng phải có cùng kiểu tham số.

Giá trị trả về

bool

• Trả về true nếu biểu thức so sánh là đúng, false nếu sai.

Đặc điểm

1. So sánh nội dung, không so sánh thứ tự: Các toán tử quan hệ so sánh nội dung của hai std::unordered_multimap, không quan tâm đến thứ tự cụ thể của các phần tử bên trong (vì std::unordered_multimap không lưu trữ phần tử theo thứ tự).
2. Phụ thuộc vào toán tử == của key và value: Việc so sánh các phần tử của std::unordered_multimap sử dụng toán tử == của key_type và mapped_type. Do đó, kiểu key_type và mapped_type của std::unordered_multimap phải hỗ trợ toán tử ==.
3. Phụ thuộc vào key_eq(): Việc xác định hai phần tử có bằng nhau hay không còn phụ thuộc vào hàm key_eq() (equality comparison function) của std::unordered_multimap.
4. Chỉ hỗ trợ == và !=: std::unordered_multimap chỉ hỗ trợ toán tử == và !=, không hỗ trợ các toán tử so sánh thứ tự <, >, <=, >= vì các phần tử không được sắp xếp.
5. Không làm thay đổi map: Các toán tử này là const, không làm thay đổi nội dung của 2 map đang được so sánh.
6. Độ phức tạp:
   • Trường hợp tốt nhất (hai map khác kích thước): O(1).
   • Trường hợp trung bình: O(n), với n là số phần tử trong map.
   • Trường hợp xấu nhất: O(n²).

Ví dụ

#include <iostream>
#include <unordered_map>

int main() {
  std::unordered_multimap<int, std::string> ummap1 = {{1, "one"}, {2, "two"}, {3, "three"}, {1, "another one"}};
  std::unordered_multimap<int, std::string> ummap2 = {{3, "three"}, {2, "two"}, {1, "one"}, {1, "another one"}};
  std::unordered_multimap<int, std::string> ummap3 = {{1, "one"}, {2, "two"}, {4, "four"}};
  std::unordered_multimap<int, std::string> ummap4 = {{1, "one"}, {2, "two"}};

  std::cout << "ummap1 == ummap2: " << (ummap1 == ummap2) << '\n'; // Output: ummap1 == ummap2: 1 (true) - cùng phần tử, số lần xuất hiện giống nhau, không quan trọng thứ tự
  std::cout << "ummap1 != ummap3: " << (ummap1 != ummap3) << '\n'; // Output: ummap1 != ummap3: 1 (true) - phần tử khác nhau
  std::cout << "ummap1 == ummap4: " << (ummap1 == ummap4) << '\n'; // Output: ummap1 == ummap4: 0 (false) - kích thước khác nhau
  std::cout << "ummap1 != ummap4: " << (ummap1 != ummap4) << '\n'; // Output: ummap1 != ummap4: 1 (true) - kích thước khác nhau

  return 0;
}

Các hàm liên quan

equal_range	Trả về một cặp iterator xác định phạm vi các phần tử trong std::unordered_multimap có key bằng với giá trị key cho trước
=	Gán nội dung của một std::unordered_multimap khác hoặc một initializer_list cho std::unordered_multimap hiện tại