std::list::insert

#include <list>

// Phiên bản 1: Chèn một phần tử
iterator insert(const_iterator pos, const value_type& val);
iterator insert(const_iterator pos, value_type&& val); // (since C++11)

// Phiên bản 2: Chèn nhiều phần tử có cùng giá trị
void insert(const_iterator pos, size_type count, const value_type& val);

// Phiên bản 3: Chèn các phần tử từ một phạm vi khác
template <class InputIterator>
void insert(const_iterator pos, InputIterator first, InputIterator last);

// Phiên bản 4: Chèn các phần tử từ một initializer_list (C++11)
iterator insert(const_iterator pos, initializer_list<value_type> ilist);

Chèn một hoặc nhiều phần tử mới vào một vị trí cụ thể trong std::list.

Tham số

pos

• Iterator trỏ đến vị trí mà trước đó phần tử mới sẽ được chèn vào. pos phải là một iterator hợp lệ trong std::list.

val

• Giá trị của phần tử cần chèn (phiên bản 1 và 2).

count

• Số lượng phần tử cần chèn (phiên bản 2).

ilist

• initializer_list chứa các phần tử cần chèn (phiên bản 4).

first, last

• Iterator xác định phạm vi các phần tử cần chèn (phiên bản 3).

Giá trị trả về

iterator

• (Phiên bản 1 và 4) Trả về một iterator trỏ đến phần tử đầu tiên được chèn vào.

void

• (Phiên bản 2 và 3) Không trả về giá trị nào.

Đặc điểm

1. Chèn vào vị trí bất kỳ: insert() cho phép bạn chèn phần tử vào bất kỳ vị trí hợp lệ nào trong std::list.
2. Tăng kích thước: insert() làm tăng kích thước của std::list tương ứng với số lượng phần tử được chèn.
3. Hỗ trợ nhiều kiểu dữ liệu: insert() có thể chèn các phần tử đơn lẻ, nhiều phần tử có cùng giá trị, các phần tử từ initializer_list hoặc từ một phạm vi được xác định bởi iterator.
4. 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.
5. Có thể làm thay đổi iterator: Việc chèn phần tử vào std::list có thể làm thay đổi (invalidate) các iterator đang trỏ đến các phần tử trong std::list ngoại trừ iterator pos (iterator pos sẽ trỏ đến phần tử trước phần tử mới được chèn).
6. Trường hợp pos không hợp lệ: Nếu pos không hợp lệ (ví dụ: không trỏ đến std::list hiện tại), hành vi là không xác định.
7. Độ phức tạp:
   • Chèn một phần tử: O(1).
   • Chèn nhiều phần tử: O(n), với n là số phần tử được chèn.

Ví dụ

#include <iostream>
#include <list>
#include <vector>

int main() {
  std::list<int> mylist = {10, 20, 30, 40};

  // Phiên bản 1: Chèn 15 vào trước phần tử thứ hai (có giá trị 20)
  auto it = mylist.begin();
  std::advance(it, 1);
  mylist.insert(it, 15);
  std::cout << "mylist after insert(it, 15):";
  for (int x : mylist) std::cout << ' ' << x; // Output: mylist after insert(it, 15): 10 15 20 30 40
  std::cout << '\n';

  // Phiên bản 1 (move): Chèn 16 vào trước phần tử thứ ba (có giá trị 20)
  int val = 16;
  mylist.insert(++++mylist.begin(), std::move(val)); 
  std::cout << "mylist after insert(it, std::move(16)) :";
  for (int x : mylist) std::cout << ' ' << x; // Output: mylist after insert(it, std::move(16)) : 10 15 16 20 30 40
  std::cout << '\n';

  // Phiên bản 2: Chèn hai phần tử có giá trị 5 vào đầu list
  mylist.insert(mylist.begin(), 2, 5);
  std::cout << "mylist after insert(mylist.begin(), 2, 5):";
  for (int x : mylist) std::cout << ' ' << x; // Output: mylist after insert(mylist.begin(), 2, 5): 5 5 10 15 16 20 30 40
  std::cout << '\n';

  // Phiên bản 4: Chèn các phần tử từ initializer list vào trước phần tử cuối cùng
  mylist.insert(mylist.end(), {99, 88, 77});
  std::cout << "mylist after insert(mylist.end(), {99, 88, 77}):";
  for (int x : mylist) std::cout << ' ' << x; // Output: mylist after insert(mylist.end(), {99, 88, 77}): 5 5 10 15 16 20 30 40 99 88 77
  std::cout << '\n';

  // Phiên bản 3: Chèn các phần tử từ một vector vào giữa list
  std::vector<int> myvector = {1, 2, 3};
  mylist.insert(++++mylist.begin(), myvector.begin(), myvector.end());
  std::cout << "mylist after insert(++++mylist.begin(), myvector.begin(), myvector.end()):";
  for (int x : mylist) std::cout << ' ' << x; // Output: mylist after insert(++++mylist.begin(), myvector.begin(), myvector.end()): 5 5 1 2 3 10 15 16 20 30 40 99 88 77
  std::cout << '\n';

  return 0;
}

Các hàm liên quan

splice	Chuyển (transfer) các phần tử từ một std::list khác sang std::list hiện tại, tại một vị trí xác định
merge	Hợp nhất (merge) hai std::list đã được sắp xếp thành một std::list duy nhất
push_back	Thêm một phần tử mới vào cuối std::list
push_front	Thêm một phần tử mới vào đầu std::list
erase	Xóa một hoặc nhiều phần tử khỏi std::list tại một vị trí cụ thể hoặc trong một phạm vi