std::map::insert

#include <map>

// Phiên bản 1: Chèn một cặp giá trị (pair) (C++98 và C++11)
std::pair<iterator, bool> insert(const value_type& val);
std::pair<iterator, bool> 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::map.

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ề std::pair<iterator, bool>.
  • iterator: Trỏ đến phần tử có key tương đương với key đã chèn (có thể là phần tử đã tồn tại hoặc phần tử mới được chèn).
  • bool: true nếu phần tử được chèn thành công (key mới), false nếu phần tử đã tồn tại (chèn thất bại).
• Phiên bản 2:
  • Trả về iterator trỏ đến phần tử có key tương đương với key đã chèn (có thể là phần tử đã tồn tại hoặc phần tử mới được chèn).
• Phiên bản 3 và 4:
  • void: Không trả về giá trị nào.

Đặc điểm

1. Cách hoạt động: Vì std::map lưu trữ các phần tử theo key duy nhất và được sắp xếp, nên việc chèn phần tử sẽ diễn ra theo cách sau:
   • Nếu key của phần tử được chèn chưa tồn tại trong std::map, phần tử mới sẽ được chèn vào đúng vị trí để duy trì thứ tự sắp xếp.
   • Nếu key của phần tử được chèn đã tồn tại trong std::map, việc chèn sẽ thất bại và std::map không thay đổi.
2. Chèn phần tử duy nhất theo key: std::map chỉ lưu trữ các phần tử có key duy nhất. Việc chèn phần tử có key đã tồn tại sẽ bị bỏ qua (đối với insert()).
3. Giữ nguyên thứ tự sắp xếp: insert() đảm bảo các phần tử trong std::map luôn được sắp xếp theo key sau khi chèn.
4. 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.
5. 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.
6. Có thể làm thay đổi iterator: Việc chèn phần tử vào std::map có thể làm thay đổi (invalidate) các iterator đang trỏ đến các phần tử khác trong std::map, trừ iterator được trả về bởi hàm insert().
7. 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ệ.
8. Độ phức tạp:
   • Chèn một phần tử: O(log n), với n là số phần tử trong std::map.
   • 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::map.

Ví dụ

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

int main() {
  std::map<std::string, int> mymap;

  // Phiên bản 1: Chèn từng phần tử
  auto ret = mymap.insert(std::make_pair("apple", 1));
  if (ret.second) {
    std::cout << "Insertion of apple successful.\n";
  }
  mymap.insert(std::pair<std::string, int>("banana", 2)); // C++98
  mymap.insert({"orange", 3}); // C++11 initializer list trong hàm insert

  // Thử chèn một phần tử có key đã tồn tại
  ret = mymap.insert(std::make_pair("apple", 10)); // Chèn thất bại
  if (!ret.second) {
    std::cout << "Insertion of apple failed (key already exists).\n";
    std::cout << "Existing value for apple: " << ret.first->second << std::endl;
  }

  // Phiên bản 2: Chèn với gợi ý vị trí
  auto it = mymap.find("banana"); // Giả sử ta biết "banana" ở gần vị trí cần chèn
  mymap.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}};
  mymap.insert(vec.begin(), vec.end());

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

  std::cout << "mymap after insertions:\n";
  for (const auto& pair : mymap) {
    std::cout << pair.first << ": " << pair.second << '\n';
  }
  // Output:
  // Insertion of apple successful.
  // Insertion of apple failed (key already exists).
  // Existing value for apple: 1
  // mymap after insertions:
  // apple: 1
  // banana: 2
  // grape: 4
  // kiwi: 5
  // mango: 6
  // melon: 7
  // orange: 3
  // pear: 8

  return 0;
}

Các hàm liên quan

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