std::unordered_multimap::erase

#include <unordered_map>

// Phiên bản 1: Xóa phần tử tại vị trí được chỉ định
iterator erase(const_iterator pos);

// Phiên bản 2: Xóa các phần tử trong một phạm vi
iterator erase(const_iterator first, const_iterator last);

// Phiên bản 3: Xóa phần tử có key cụ thể
size_type erase(const key_type& key);

Xóa một hoặc nhiều phần tử khỏi std::unordered_multimap.

Tham số

pos

• Iterator trỏ đến phần tử cần xóa (phiên bản 1). pos phải là một iterator hợp lệ và có thể dereference được trong std::unordered_multimap.

first, last

• Iterator xác định phạm vi các phần tử cần xóa (phiên bản 2). first trỏ đến phần tử đầu tiên cần xóa, last trỏ đến phần tử sau phần tử cuối cùng cần xóa (past-the-end).

key

• Giá trị của key cần xóa (phiên bản 3).

Giá trị trả về

• Phiên bản 1 và 2:
  • iterator: Trả về một iterator trỏ đến phần tử theo sau phần tử cuối cùng bị xóa. Nếu không có phần tử nào như vậy (ví dụ: xóa phần tử cuối cùng của std::unordered_multimap), hàm trả về end().
• Phiên bản 3:
  • size_type: Trả về số lượng phần tử đã bị xóa.

Đặc điểm

1. Xóa phần tử tại vị trí cụ thể, theo giá trị hoặc theo phạm vi: erase() cho phép bạn xóa một phần tử duy nhất bằng iterator, xóa một dãy các phần tử liên tiếp bằng iterator, hoặc xóa tất cả các phần tử có key khớp với giá trị cho trước.
2. Giảm kích thước: erase() làm giảm kích thước của std::unordered_multimap tương ứng với số lượng phần tử bị xóa.
3. Hành vi không xác định khi iterator không hợp lệ: Gọi erase() với iterator không hợp lệ (ví dụ: pos trỏ đến end(), hoặc first, last không hợp lệ) sẽ dẫn đến hành vi không xác định.
4. Có thể làm thay đổi iterator: Việc xóa phần tử khỏi std::unordered_multimap có thể làm thay đổi (invalidate) các iterator đang trỏ đến các phần tử trong std::unordered_multimap do việc rehash có thể xảy ra. Iterator trả về bởi hàm erase() là hợp lệ và trỏ đến phần tử tiếp theo sau phần tử cuối cùng bị xóa.
5. Không trả về giá trị phần tử bị xóa: erase() không trả về giá trị (value) của phần tử bị xóa.
6. An toàn exception: Nếu exception xảy ra trong khi erase đang chạy, ví dụ từ destructor của value_type, thì các thay đổi đã thực hiện (các phần tử đã xóa) vẫn có hiệu lực.
7. Độ phức tạp:
   • Xóa một phần tử bằng iterator (phiên bản 1): Trung bình O(1), trường hợp xấu nhất O(N), với N là số phần tử trong std::unordered_multimap.
   • Xóa phần tử theo key (phiên bản 3): Trung bình O(M) (với M là số phần tử bị xóa), trường hợp xấu nhất O(N), với N là số phần tử trong std::unordered_multimap.
   • Xóa nhiều phần tử (phiên bản 2): O(N), với N là số phần tử bị xóa.

Ví dụ

#include <iostream>
#include <unordered_map>

int main() {
  std::unordered_multimap<std::string, int> myumm = {
    {"apple", 1},
    {"banana", 2},
    {"orange", 3},
    {"apple", 4},
    {"grape", 5}
  };

  // Phiên bản 1: Xóa phần tử có key "banana"
  auto it = myumm.find("banana");
  if (it != myumm.end()) {
    myumm.erase(it); // Xóa phần tử được trỏ bởi it
    std::cout << "Removed element with key 'banana'\n";
  }

  // Phiên bản 2: Xóa hai phần tử đầu tiên
  // Lưu ý: Vì unordered_multimap không có thứ tự, nên "hai phần tử đầu tiên" có thể không như mong đợi
  //          Nên sử dụng cách này khi bạn chắc chắn về vị trí iterator
  auto first = myumm.begin();
  auto last = myumm.begin();
  std::advance(last, 2); // Di chuyển last hai vị trí

  
  if (std::distance(first, last) > 0) // Đảm bảo phạm vi hợp lệ
      myumm.erase(first, last);

  std::cout << "myumm after erasing elements:\n";
  for (const auto& pair : myumm) {
    std::cout << pair.first << ": " << pair.second << '\n';
  }
  // Output:
  // myumm after erasing elements:
  // grape: 5
  // apple: 1
  // apple: 4
  // (thứ tự có thể khác)

  // Phiên bản 3: Xóa tất cả phần tử có key "apple"
  size_type num_removed = myumm.erase("apple");
  std::cout << "Number of elements with key 'apple' removed: " << num_removed << '\n'; // Output: Number of elements with key 'apple' removed: 2

  // In ra các phần tử còn lại trong unordered_multimap
  std::cout << "myumm after erasing elements with key 'apple':\n";
  for (const auto& pair : myumm) {
    std::cout << pair.first << ": " << pair.second << '\n';
  }
  // Output:
  // myumm after erasing elements with key 'apple':
  // grape: 5
  // (thứ tự có thể khác)

  return 0;
}

Các hàm liên quan

clear	Xóa tất cả các phần tử khỏi std::unordered_multimap
insert	Chèn một phần tử mới (cặp key-value) vào std::unordered_multimap
find	Tìm kiếm một phần tử có key bằng với giá trị key cho trước trong std::unordered_multimap