std::multimap::emplace_hint

#include <map>

template <class... Args>
iterator emplace_hint(const_iterator hint, Args&&... args);

Xây dựng (construct) một phần tử mới (cặp key-value) trực tiếp trong std::multimap, tương tự như emplace(), nhưng bạn có thể cung cấp thêm một gợi ý (hint) về vị trí chèn để tối ưu hóa hiệu suất.

Tham số

`hint`

const_iterator trỏ đến vị trí gợi ý để chèn phần tử mới.

`args`

Danh sách các đối số (có thể trống) được sử dụng để khởi tạo phần tử mới (cặp key-value). Các đối số này sẽ được truyền đến constructor của std::pair<const Key, T>.

Giá trị trả về

iterator: Trả về một iterator trỏ đến phần tử vừa được chèn vào.

Đặc điểm

Xây dựng phần tử tại chỗ (In-place construction): Giống như emplace(), emplace_hint() tạo phần tử mới trực tiếp trong bộ nhớ của std::multimap, tránh việc tạo ra các đối tượng tạm thời không cần thiết.
Tránh sao chép và di chuyển: Bằng cách xây dựng phần tử tại chỗ, emplace_hint() giúp tránh việc sao chép (copy) hoặc di chuyển (move) các đối tượng.
Hỗ trợ variadic template: emplace_hint() sử dụng variadic template (Args&&... args), cho phép nó nhận số lượng đối số tùy ý, phù hợp với constructor của kiểu std::pair<const Key, T>.
Gợi ý vị trí chèn (hint): Tham số hint cho phép bạn cung cấp gợi ý về vị trí chèn, có thể cải thiện hiệu suất nếu gợi ý chính xác.
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ử trong std::multimap.
Phân biệt với emplace(): emplace_hint() tương tự emplace() nhưng có thêm tham số hint để gợi ý vị trí chèn, giúp tối ưu hiệu suất trong trường hợp hint chính xác.
Phân biệt với insert(): insert() sẽ tạo bản sao hoặc di chuyển phần tử được truyền vào trong khi đó emplace_hint() sẽ xây dựng phần tử tại chỗ trong std::multimap.
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, emplace_hint() có thể ném ra ngoại lệ std::bad_alloc. Ngoài ra, nếu constructor của std::pair<const Key, T> ném ngoại lệ, emplace_hint() cũng sẽ ném ngoại lệ.
Chèn phần tử duy nhất theo key: std::multimap chỉ lưu trữ các phần tử có key duy nhất. Nếu bạn cố gắng chèn một phần tử có key đã tồn tại, emplace_hint() sẽ không chèn thêm phần tử mới và iterator trả về sẽ trỏ đến phần tử đã tồn tại.
Thứ tự được duy trì: emplace_hint() vẫn đảm bảo các phần tử trong std::multimap được sắp xếp đúng thứ tự sau khi chèn, bất kể gợi ý có chính xác hay không.
Luôn chèn phần tử: Khác với emplace() của std::multimap, emplace_hint() của std::multimap luôn chèn phần tử mới kể cả khi key đã tồn tại
Độ phức tạp:
- O(log n) trong trường hợp bình thường (khi hint không chính xác), với n là số phần tử trong std::multimap.
- Amortized O(1) nếu hint trỏ đến ngay trước vị trí mà phần tử mới nên được chèn.

Ví dụ

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

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

  // Chèn các phần tử, sử dụng emplace_hint() với gợi ý
  auto it = mymultimap.emplace_hint(mymultimap.end(), "banana", 2); // Gợi ý chèn vào cuối (có thể sai)
  it = mymultimap.emplace_hint(it, "apple", 1);   // Gợi ý chèn vào trước "banana" (có thể đúng)
  it = mymultimap.emplace_hint(mymultimap.end(), "orange", 3); // Gợi ý chèn vào cuối (có thể đúng)
  it = mymultimap.emplace_hint(it, "apple", 4); // Chèn "apple" lần nữa

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

  return 0;
}

Các hàm liên quan


emplace	Xây dựng (construct) một phần tử mới trực tiếp trong std::multimap tại vị trí thích hợp
insert	Chèn một phần tử mới (cặp `key-value`) vào std::multimap
erase	Xóa một hoặc nhiều phần tử khỏi std::multimap

Tham số​

hint​

args​

Giá trị trả về​

Đặc điểm​

Ví dụ​

Các hàm liên quan​