std::multimap::operator=

#include <map>

// 1. Copy assignment operator
multimap& operator=(const multimap& other);

// 2. Move assignment operator (C++11)
multimap& operator=(multimap&& other) noexcept;

// 3. Initializer list assignment operator (C++11)
multimap& operator=(initializer_list<value_type> ilist);

Gán nội dung của một std::multimap khác hoặc một initializer_list cho std::multimap hiện tại.

Tham số

other

• (Phiên bản 1 và 2) std::multimap nguồn cần gán.

ilist

• (Phiên bản 3) Danh sách khởi tạo chứa các phần tử cần gán.

Giá trị trả về

multimap&

• Tham chiếu đến std::multimap hiện tại (sau khi đã gán).

Đặc điểm

1. Thay thế nội dung: Các toán tử gán thay thế toàn bộ nội dung hiện tại của std::multimap bằng nội dung mới.
2. Copy vs. Move:
   • Copy assignment tạo một bản sao độc lập của std::multimap nguồn.
   • Move assignment di chuyển tài nguyên (dữ liệu) từ std::multimap nguồn sang std::multimap đích, làm cho std::multimap nguồn trở thành rỗng, hiệu quả hơn sao chép.
3. Initializer list: Phiên bản gán từ danh sách khởi tạo cung cấp cách thức tiện lợi để gán các giá trị cố định cho std::multimap.
4. Tự gán (self-assignment): Toán tử operator= được cài đặt để tự phát hiện và xử lý đúng các trường hợp tự gán a = a;
5. An toàn exception: Nếu exception xảy ra trong khi copy assignment đang copy các phần tử, multimap đích sẽ không thay đổi. Nếu exception xảy ra khi move assignment đang move các phần tử, thì multimap nguồn vẫn hợp lệ nhưng trạng thái không xác định.
6. noexcept: Move assignment operator được đánh dấu là noexcept, nghĩa là nó được đảm bảo không ném ra ngoại lệ nào.
7. Độ phức tạp:
   • Copy assignment: Độ phức tạp tuyến tính theo kích thước của std::multimap nguồn (O(n)).
   • Move assignment: Độ phức tạp thường là hằng số (O(1)).
   • Initializer list assignment: Độ phức tạp tuyến tính theo kích thước của danh sách khởi tạo (O(n)).

Ví dụ

#include <iostream>
#include <map>

int main() {
  std::multimap<std::string, int> mmap1 = {{"apple", 1}, {"banana", 2}, {"apple", 3}};
  std::multimap<std::string, int> mmap2 = {{"grape", 4}, {"kiwi", 5}};
  std::multimap<std::string, int> mmap3;

  // 1. Copy assignment
  mmap3 = mmap1;
  std::cout << "mmap3 after copy assignment from mmap1:\n";
  for (const auto& pair : mmap3) {
    std::cout << pair.first << ": " << pair.second << '\n';
  }
  // Output:
  // mmap3 after copy assignment from mmap1:
  // apple: 1
  // apple: 3
  // banana: 2

  // 2. Move assignment
  mmap3 = std::move(mmap2);
  std::cout << "mmap3 after move assignment from mmap2:\n";
  for (const auto& pair : mmap3) {
    std::cout << pair.first << ": " << pair.second << '\n';
  }
  // Output:
  // mmap3 after move assignment from mmap2:
  // grape: 4
  // kiwi: 5

  std::cout << "mmap2 after move assignment:\n";
  for (const auto& pair : mmap2) {
    std::cout << pair.first << ": " << pair.second << '\n';
  }
  // Output:
  // mmap2 after move assignment:
  // (empty)

  // 3. Initializer list assignment
  mmap3 = {{"pear", 6}, {"mango", 7}, {"pear", 8}};
  std::cout << "mmap3 after initializer list assignment:\n";
  for (const auto& pair : mmap3) {
    std::cout << pair.first << ": " << pair.second << '\n';
  }
  // Output:
  // mmap3 after initializer list assignment:
  // mango: 7
  // pear: 6
  // pear: 8

  return 0;
}

Các hàm liên quan

insert	Chèn một phần tử mới (cặp key-value) vào std::multimap
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