public member function

std::forward_list::assign

<forward_list>
range (1)
template <class InputIterator>
  void assign ( InputIterator first, InputIterator last );
fill (2)
void assign ( size_type n, const value_type& val );
initializer list (3)
void assign ( initializer_list<value_type> il );
Assign content
Assigns new content to the container, dropping all the elements contained in the container object before the call and replacing them by those specified by the parameters:

In the range version (1), the new content of the container object is a copy of those contained in the range between first and last.

In the fill version (2), the new content is the repetition n times of copies of val.

In the third version (initializer list), the new content is a copy of the values passed as initializer list.

Parameters

first, last
Input iterators to the initial and final positions in a sequence. The range used is [first,last), which includes all the elements between first and last, including the element pointed by first but not the element pointed by last.
The template type can be any type of input iterator.
n
New size for the container.
Member type size_type is an unsigned integral type.
val
Value to be used to fill each of the elements in the container. Each element is constructed using its copy-constructor.
Member type value_type is the type of the elements in the container, defined in forward_list as an alias of its first template parameter (T).
il
An initializer_list object. The compiler will automatically construct such objects from initializer list declarators.

Return value

none

Example

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
// forward_list::assign
#include <iostream>
#include <forward_list>

int main ()
{
  std::forward_list<int> first;
  std::forward_list<int> second;

  first.assign (4,15);                           // 15 15 15 15

  second.assign (first.begin(),first.end());     // 15 15 15 15

  first.assign ( {77, 2, 16} );                  // 77 2 16

  std::cout << "first contains: ";
  for (int& x : first) std::cout << " " << x;
  std::cout << std::endl;

  std::cout << "second contains: ";
  for (int& x : second) std::cout << " " << x;
  std::cout << std::endl;

  return 0;
}

Output:
first contains: 77 2 16
second contains: 15 15 15 15

Complexity

Linear on initial and final sizes (destruction, copy construction).

Iterator validity

All iterators, references and pointers are invalidated.

See also