public member function

std::vector::assign

<vector>
range (1)
template <class InputIterator>
  void assign (InputIterator first, InputIterator last);
fill (2)
void assign (size_type n, const value_type& val);
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 vector content
Assigns new contents to the vector. Any elements contained in the object before the call are removed from the container and destroyed.

In the range version (1), the new contents are copies of the elements in the range between first and last.

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.

The container size is modified accordingly.

This causes an automatic reallocation of the allocated storage space if -and only if- the new vector size surpasses the current vector capacity.

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 implicitly convertible to value_type.
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 vector 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
 
// vector assign
#include <iostream>
#include <vector>

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

  first.assign (7,100);             // 7 ints with a value of 100

  std::vector<int>::iterator it;
  it=first.begin()+1;

  second.assign (it,first.end()-1); // the 5 central values of first

  int myints[] = {1776,7,4};
  third.assign (myints,myints+3);   // assigning from array.

  std::cout << "Size of first: " << int (first.size()) << '\n';
  std::cout << "Size of second: " << int (second.size()) << '\n';
  std::cout << "Size of third: " << int (third.size()) << '\n';
  return 0;
}

Output:
Size of first: 7
Size of second: 5
Size of third: 3

Complexity

Linear on initial and final sizes (destruction, copy construction).
Additionally, in the range version (1), if InputIterator is not at least of a forward iterator category (i.e., it is just an input iterator) the new capacity cannot be determined beforehand and the operation incurs in additional logarithmic complexity in the new size (reallocations).

Iterator validity

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

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 throws if copying an element throws, if the internal allocator throws reallocating storage, or if an iterator throws.

See also

vector::operator=
Copy vector content (public member function )
vector::resize
Change size (public member function )

C++