std::map::operator=

#include <map>

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

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

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

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

Tham số

other

• (Phiên bản 1 và 2) std::map 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 (các phần tử là các std::pair).

Giá trị trả về

map&

• Tham chiếu đến std::map 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::map 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::map nguồn.
   • Move assignment di chuyển tài nguyên (dữ liệu) từ std::map nguồn sang std::map đích, làm cho std::map 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::map.
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ử, map đích sẽ không thay đổi. Nếu exception xảy ra khi move assignment đang move các phần tử, thì map 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::map 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>
#include <string>

int main() {
  std::map<std::string, int> map1 = {{"apple", 1}, {"banana", 2}, {"orange", 3}};
  std::map<std::string, int> map2 = {{"grape", 4}, {"kiwi", 5}};
  std::map<std::string, int> map3;

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

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

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

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

  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::map
[]	Truy cập phần tử có key tương ứng trong std::map