std::multimap::insert

#include <map>

// 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);

Chèn một phần tử mới (cặp key-value) vào std::multimap. std::multimap cho phép các key trùng lặp, do đó insert() sẽ luôn chèn phần tử mới vào std::multimap, ngay cả khi key đó đã tồn tại. Các phần tử trong std::multimap vẫn được duy trì thứ tự sắp xếp sau khi chèn.

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:
  • Trả về iterator trỏ đến phần tử vừa được chèn vào trong std::multimap.
• Phiên bản 2:
  • Trả về iterator trỏ đến phần tử vừa được chèn vào trong std::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::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::multimap.
2. Giữ nguyên thứ tự sắp xếp: insert() đảm bảo các phần tử trong std::multimap luôn được sắp xếp theo key sau khi chèn.
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.
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::multimap có thể làm thay đổi (invalidate) các iterator đang trỏ đến các phần tử khác trong std::multimap. Iterator được hàm trả về vẫn sẽ hợp lệ sau khi chèn.
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ử: O(log n), với n là số phần tử trong std::multimap.
   • Chèn nhiều phần tử (phiên bản 3 và 4): O(k log n), với k là số phần tử được chèn và n là số phần tử trong std::multimap.

Ví dụ

#include <iostream>
#include <map>
#include <string>
#include <vector>

int main() {
  std::multimap<std::string, int> mymultimap;

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

  std::cout << "mymultimap after inserting elements:\n";
  for (const auto& pair : mymultimap) {
    std::cout << pair.first << ": " << pair.second << '\n';
  }
  // Output:
  // mymultimap after inserting elements:
  // apple: 1
  // apple: 4
  // banana: 2
  // orange: 3

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

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

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

  std::cout << "mymultimap after more insertions:\n";
  for (const auto& pair : mymultimap) {
    std::cout << pair.first << ": " << pair.second << '\n';
  }
  // Output:
  // mymultimap after more insertions:
  // apple: 1
  // apple: 4
  // apple: 8
  // banana: 2
  // grape: 4
  // kiwi: 5
  // mango: 6
  // orange: 3
  // pear: 7

  return 0;
}

Các hàm liên quan

find	Tìm kiếm một phần tử có key bằng với giá trị key cho trước trong std::multimap
erase	Xóa một hoặc nhiều phần tử khỏi std::multimap