std::unordered_multimap::rehash

#include <unordered_map>

void rehash(size_type count);

Thiết lập số lượng bucket trong bảng băm của std::unordered_multimap thành ít nhất count (tham số truyền vào). Việc này sẽ dẫn đến quá trình băm lại (rehashing), tức là tất cả các phần tử sẽ được phân phối lại vào các bucket dựa trên số lượng bucket mới và hàm băm.

Tham số

`count`

Số lượng bucket tối thiểu mà bạn muốn std::unordered_multimap sử dụng.

Giá trị trả về

Không có giá trị trả về

Đặc điểm

Thiết lập số lượng bucket tối thiểu: rehash(count) yêu cầu std::unordered_multimap sử dụng ít nhất count bucket. Số lượng bucket thực tế có thể lớn hơn count tùy thuộc vào trình triển khai và thuật toán được sử dụng.
Băm lại (rehashing): Khi gọi rehash(), std::unordered_multimap sẽ băm lại tất cả các phần tử hiện có và phân phối chúng vào các bucket mới dựa trên số lượng bucket mới và hàm băm.
Có thể tốn kém: Rehashing là một thao tác tốn kém vì nó liên quan đến việc băm lại và di chuyển tất cả các phần tử.
Làm thay đổi iterator: Rehashing chắc chắn sẽ làm thay đổi (invalidate) tất cả các iterator đang trỏ đến các phần tử trong std::unordered_multimap.
Không đảm bảo duy trì thứ tự: std::unordered_multimap không đảm bảo thứ tự của các phần tử, và sau khi rehash, thứ tự duyệt qua các phần tử có thể thay đổi.
Nên gọi trước khi chèn nhiều phần tử: Nếu bạn biết trước số lượng phần tử mà bạn sẽ chèn vào std::unordered_multimap, bạn nên gọi rehash() (hoặc reserve()) trước khi chèn để tránh việc rehashing tự động xảy ra nhiều lần trong quá trình chèn, tối ưu hiệu suất.
Liên quan đến load_factor() và max_load_factor(): rehash() có liên quan đến hệ số tải (load factor) và hệ số tải tối đa (max_load_factor()). Khi hệ số tải vượt quá max_load_factor(), std::unordered_multimap sẽ tự động thực hiện rehashing.
Có thể ném ngoại lệ: Nếu việc cấp phát bộ nhớ thất bại, rehash() có thể ném ra ngoại lệ std::bad_alloc. Ngoài ra, nếu copy constructor, move constructor, hash function, equal function, hoặc destructor của value_type ném ngoại lệ khi rehash, rehash() cũng sẽ ném ngoại lệ.
Độ phức tạp: Độ phức tạp của rehash() là O(n), với n là số phần tử trong std::unordered_multimap.

Phân biệt với reserve()

rehash(n): Thiết lập số lượng bucket ít nhất là n.
reserve(n): Yêu cầu std::unordered_multimap cấp phát đủ bộ nhớ để chứa ít nhất n phần tử mà không cần phải rehash. reserve có thể làm thay đổi số lượng bucket.

Ví dụ

#include <iostream>
#include <unordered_map>

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

  std::cout << "Initial bucket_count: " << myumm.bucket_count() << '\n';

  myumm.rehash(20); // Yêu cầu unordered_multimap sử dụng ít nhất 20 bucket

  std::cout << "Bucket_count after rehash(20): " << myumm.bucket_count() << '\n';

  // Chèn thêm phần tử để thấy số bucket thay đổi
  for (int i = 0; i < 50; ++i) {
    myumm.emplace(std::to_string(i), i);
  }

  std::cout << "Bucket_count after adding elements: " << myumm.bucket_count() << '\n';
  std::cout << "Load factor: " << myumm.load_factor() << '\n';
  std::cout << "Max load factor: " << myumm.max_load_factor() << '\n';

  return 0;
}

Các hàm liên quan


reserve	Thay đổi số lượng phần tử mà std::unordered_multimap có thể chứa mà không cần phải rehash
bucket_count	Trả về số lượng bucket (hay còn gọi là giỏ) hiện tại trong std::unordered_multimap
max_load_factor	Truy vấn hoặc thiết lập hệ số tải tối đa (maximum load factor) của std::unordered_multimap
size	Trả về số lượng phần tử hiện có trong std::unordered_multimap

Tham số​

count​

Giá trị trả về​

Đặc điểm​

Ví dụ​

Các hàm liên quan​