std::unordered_multimap::insert

#include <unordered_map>

Chèn một hoặc nhiều phần tử mới (cặp key-value) vào std::unordered_multimap. Vì std::unordered_multimap cho phép các key trùng lặp, insert() sẽ luôn chèn phần tử mới vào std::unordered_multimap, ngay cả khi key đó đã tồn tại.

// Phiên bản 1: Chèn một cặp giá trị (pair) (C++98 và C++11)
iterator insert(const value_type& val);
iterator insert(value_type&& val); // (since C++11)

// Phiên bản 2: Chèn với gợi ý vị trí (C++98 và C++11)
iterator insert(const_iterator hint, const value_type& val);
iterator insert(const_iterator hint, value_type&& val); // (since C++11)

// Phiên bản 3: Chèn các phần tử từ một phạm vi khác (C++98 và C++11)
template <class InputIterator>
void insert(InputIterator first, InputIterator last);

// Phiên bản 4: Chèn các phần tử từ initializer list (C++11)
void insert(initializer_list<value_type> ilist);

Tham số

val

• Giá trị của phần tử cần chèn, là một std::pair chứa key và value (phiên bản 1 và 2).

hint

• Iterator gợi ý vị trí chèn (phiên bản 2).

first, last

• Iterator xác định phạm vi các phần tử cần chèn (phiên bản 3).

ilist

• initializer_list chứa các phần tử cần chèn (phiên bản 4).

Giá trị trả về

• Phiên bản 1 và 2 :
  • Trả về iterator trỏ đến phần tử vừa được chèn vào trong std::unordered_multimap.
• Phiên bản 3 và 4:
  • void: Không trả về giá trị nào.

Đặc điểm

1. Chèn phần tử, cho phép trùng lặp: std::unordered_multimap cho phép lưu trữ các key trùng lặp, do đó insert() luôn chèn phần tử mới vào std::unordered_multimap, ngay cả khi key đó đã tồn tại.
2. Không đảm bảo thứ tự: std::unordered_multimap không lưu trữ phần tử theo thứ tự, vì vậy vị trí chèn không ảnh hưởng đến thứ tự duyệt.
3. Hỗ trợ gợi ý vị trí: Phiên bản insert(hint, val) cho phép bạn cung cấp gợi ý vị trí chèn, có thể giúp cải thiện hiệu suất nếu bạn biết vị trí chèn gần đúng (ít dùng với std::unordered_multimap vì không có thứ tự).
4. Hỗ trợ move semantics: Phiên bản insert(const_iterator pos, value_type&& val) (từ C++11) hỗ trợ di chuyển (move semantics), giúp tối ưu hiệu suất khi chèn các đối tượng lớn hoặc phức tạp.
5. Có thể làm thay đổi iterator: Việc chèn phần tử vào 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.
6. Có thể ném ngoại lệ: Nếu việc cấp phát bộ nhớ cho phần tử mới thất bại, insert() có thể ném ra ngoại lệ std::bad_alloc. Ngoài ra, nếu copy constructor (phiên bản 1) hoặc move constructor (phiên bản 2) của value_type ném ngoại lệ, insert cũng sẽ ném ngoại lệ.
7. Độ phức tạp:
   • Chèn một phần tử: 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.
   • Chèn nhiều phần tử (phiên bản 3 và 4): Trung bình O(K), trường hợp xấu nhất O(K*N), với K là số phần tử được chèn và N là số phần tử trong std::unordered_multimap.

Ví dụ

#include <iostream>
#include <unordered_map>
#include <string>
#include <vector>

int main() {
  std::unordered_multimap<std::string, int> myumm;

  // Phiên bản 1: Chèn từng phần tử
  myumm.insert(std::make_pair("apple", 1));
  myumm.insert(std::pair<std::string, int>("banana", 2)); // C++98
  myumm.insert({"orange", 3}); // C++11 initializer list trong hàm insert
  myumm.insert(std::make_pair("apple", 4)); // Chèn key trùng lặp

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

  // Phiên bản 2: Chèn với gợi ý vị trí (ít ý nghĩa với unordered_multimap)
  auto it = myumm.find("banana"); // Giả sử ta biết "banana" ở gần vị trí cần chèn
  myumm.insert(it, std::make_pair("grape", 4));

  // Phiên bản 3: Chèn từ một range
  std::vector<std::pair<std::string, int>> vec = {{"kiwi", 5}, {"mango", 6}};
  myumm.insert(vec.begin(), vec.end());

  // Phiên bản 4: Chèn từ initializer list
  myumm.insert({{"pear", 7}, {"apple", 8}});

  std::cout << "myumm after more insertions:\n";
  for (const auto& pair : myumm) {
    std::cout << pair.first << ": " << pair.second << '\n';
  }
  // Output:
  // myumm after more insertions:
  // pear: 7
  // mango: 6
  // kiwi: 5
  // grape: 4
  // orange: 3
  // banana: 2
  // apple: 1
  // apple: 4
  // apple: 8
  // (thứ tự có thể khác)

  return 0;
}

Các hàm liên quan

emplace	Xây dựng (construct) một phần tử mới (cặp key-value) trực tiếp trong std::unordered_multimap tại vị trí thích hợp
emplace_hint	Xây dựng (construct) một phần tử mới (cặp key-value) trực tiếp trong std::unordered_multimap với một gợi ý (hint)
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