std::forward_list::insert_after

#include <forward_list>

iterator insert_after(const_iterator pos, const value_type& val);
iterator insert_after(const_iterator pos, value_type&& val);

iterator insert_after(const_iterator pos, size_type count, const value_type& val);

iterator insert_after(const_iterator pos, initializer_list<value_type> ilist);

template <class InputIterator>
iterator insert_after(const_iterator pos, InputIterator first, InputIterator last);

Chèn một hoặc nhiều phần tử mới vào sau một vị trí iterator cho trước trong forward_list.

Tham số

pos

• const_iterator trỏ đến vị trí mà sau đó các phần tử mới sẽ được chèn vào.
• pos phải là một iterator hợp lệ trong forward_list, bao gồm cả giá trị trả về bởi before_begin() (để chèn vào đầu danh sách).

val

• Giá trị của phần tử cần chèn.

count

• Số lượng phần tử cần chèn.

ilist

• initializer_list chứa các phần tử cần chèn.

first, last

• Iterator xác định phạm vi các phần tử cần chèn.

Giá trị trả về

• Trả về một iterator trỏ đến phần tử đầu tiên được chèn vào. Nếu không có phần tử nào được chèn (ví dụ: count bằng 0 hoặc first bằng last), hàm trả về chính pos.

Đặc điểm

1. Chèn vào sau vị trí đã cho: insert_after() luôn chèn các phần tử mới vào sau vị trí được trỏ bởi iterator pos.
2. Tăng kích thước: insert_after() làm tăng kích thước của forward_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_after() 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_after(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 forward_list có thể làm thay đổi (invalidate) các iterator đang trỏ đến các phần tử phía sau vị trí chèn. Iterator pos và iterator trỏ đến các phần tử trước vị trí chèn vẫn hợp lệ.
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 forward_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ử: Độ phức tạp tuyến tính theo số lượng phần tử được chèn - O(n) với n là số phần tử được chèn.

Ví dụ

#include <iostream>
#include <forward_list>
#include <vector>

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

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

  // Phiên bản 1 (move): Chèn 16 vào sau phần tử có giá trị 15
  int val = 16;
  mylist.insert_after(++mylist.begin(), std::move(val)); 
  std::cout << "mylist after insert_after(it, std::move(16)) :";
  for (int x : mylist) std::cout << ' ' << x; // Output: mylist after insert_after(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 sau before_begin() (đầu danh sách)
  mylist.insert_after(mylist.before_begin(), 2, 5);
  std::cout << "mylist after insert_after(mylist.before_begin(), 2, 5):";
  for (int x : mylist) std::cout << ' ' << x; // Output: mylist after insert_after(mylist.before_begin(), 2, 5): 5 5 10 15 16 20 30 40
  std::cout << '\n';

  // Phiên bản 3: Chèn các phần tử từ initializer list vào sau phần tử thứ hai
  mylist.insert_after(++++mylist.begin(), {99, 88, 77});
  std::cout << "mylist after insert_after(++++mylist.begin(), {99, 88, 77}):";
  for (int x : mylist) std::cout << ' ' << x; // Output: mylist after insert_after(++++mylist.begin(), {99, 88, 77}): 5 5 99 88 77 10 15 16 20 30 40
  std::cout << '\n';

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

  return 0;
}

Các hàm liên quan

push_front	Thêm một phần tử mới vào đầu forward_list
emplace_after	Xây dựng một phần tử mới trực tiếp vào vị trí sau một iterator cho trước trong forward_list
splice_after	Chuyển (transfer) các phần tử từ một forward_list khác hoặc từ một phạm vi trong forward_list khác sang forward_list hiện tại
merge	Hợp nhất (merge) hai forward_list đã được sắp xếp thành một forward_list duy nhất
erase_after	Xóa một hoặc nhiều phần tử khỏi forward_list tại vị trí sau một iterator cho trước