public member function
<forward_list>

std::forward_list::assign

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 contents to the forward_list container, replacing its current contents, and modifying its size accordingly.

In the range version (1), the new contents are elements constructed from each of the elements in the range between first and last, in the same order.

In the fill version (2), the new contents are n elements, each initialized to a copy of val.

In the initializer list version (3), the new contents are copies of the values passed as initializer list, in the same order.

Any elements held in the container before the call are destroyed and replaced by newly constructed elements (no assignments of elements take place).

If there are changes in storage, the internal allocator is used (through its traits). It is also used to destroy all existing elements, and to construct the new ones.

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 function template argument InputIterator shall be an input iterator type that points to elements of a type from which value_type objects can be constructed.
n
New size for the container.
Member type size_type is an unsigned integral type.
val
Value to fill the container with. Each of the n elements in the container will be initialized to a copy of this value.
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.
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).

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 << '\n';

  std::cout << "second contains: ";
  for (int& x : second) std::cout << ' ' << x;
  std::cout << '\n';

  return 0;
}

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

Complexity

Linear in initial and final container sizes (destructions, constructions).

Iterator validity

All iterators, references and pointers related to this container are invalidated, except the end iterators.

Data races

All copied elements are accessed.
The container is modified.
All contained elements are modified.

Exception safety

Basic guarantee: if an exception is thrown, the container is in a valid state.
If allocator_traits::construct is not supported with the appropriate arguments for the element constructions, or if the range specified by [first,last) is not valid, it causes undefined behavior.

See also

forward_list::operator=
Assign content (public member function )
forward_list::forward_list
Construct forward_list object (public member function )
forward_list::insert_after
Insert elements (public member function )

C++