std::vector<T,Allocator>::vector
(until C++17)
(constexpr since C++20)
(noexcept since C++17)
(constexpr since C++20)
const Allocator& alloc = Allocator() );
const Allocator& alloc = Allocator() );
const Allocator& alloc = Allocator() );
(constexpr since C++20)
vector( InputIt first, InputIt last,
constexpr vector( std::from_range_t, R&& rg,
(noexcept since C++17)
(constexpr since C++20)
(constexpr since C++20)
(until C++23)
const std::type_identity_t <Allocator>& alloc );
(until C++23)
const std::type_identity_t <Allocator>& alloc );
const Allocator& alloc = Allocator() );
Constructs a new vector
from a variety of data sources, optionally using a user supplied allocator alloc.
vector
with a default-constructed allocator.Allocator
is not DefaultConstructible, the behavior is undefined.vector
with the given allocator alloc.vector
with count default-inserted objects of T
. No copies are made.vector
with count copies of elements with value value.
If T
is not CopyInsertable into vector
, the behavior is undefined.
vector
with the contents of the range [
first,
last)
. Each iterator in [
first,
last)
is dereferenced exactly once.
If InputIt
does not satisfy the requirements of LegacyInputIterator, overload (4) is called instead with arguments static_cast<size_type>(first), last and alloc.
This overload participates in overload resolution only if InputIt
satisfies the requirements of LegacyInputIterator.
If any of the following conditions is satisfied, the behavior is undefined:
-
T
is not EmplaceConstructible intovector
from *first. -
Iter
does not satisfy the requirements of LegacyForwardIterator, andT
is not MoveInsertable intovector
.
vector
with the contents of the range rg. Each iterator in rg is dereferenced exactly once.-
T
is not EmplaceConstructible intovector
from *ranges::begin (rg). -
R
models neithersized_range
norforward_range
, andT
is not MoveInsertable intovector
.
vector
with the contents of other.
The allocator is obtained as if by calling
std::allocator_traits <Allocator>::select_on_container_copy_construction
(other.get_allocator()).
vector
with the contents of other. The allocator is obtained by move construction from other.get_allocator().Parameters
Complexity
- If
InputIt
satisfies the requirements of LegacyForwardIterator, then:
- The copy constructor of
T
is only called \(\scriptsize N \)N times. - No reallocation occurs.
- The copy constructor of
- Otherwise:
- The copy constructor of
T
is called \(\scriptsize O(N) \)O(N) times. - Reallocation occurs \(\scriptsize O(\log N) \)O(log N) times.
- The copy constructor of
- If
R
modelsforward_range
orsized_range
, then:
- If
R
satisfies one of the following conditions:
-
R
models approximately_sized_range, and ranges::distance (rg) <= ranges::reserve_hint(rg) is true. -
R
modelsforward_range
andR
does not model approximately_sized_range.
-
- then:
- Initializes exactly \(\scriptsize N \)N elements from the result of dereferencing successive iterators of rg.
- No reallocation occurs.
- Otherwise:
- The copy or move constructor of
T
is called \(\scriptsize O(N) \)O(N) times. - Reallocation occurs \(\scriptsize O(\log N) \)O(log N) times.
- The copy or move constructor of
Exceptions
Calls to Allocator::allocate may throw.
Notes
After container move construction (overload (8)), references, pointers, and iterators (other than the end iterator) to other remain valid, but refer to elements that are now in *this. The current standard makes this guarantee via the blanket statement in [container.reqmts]/67, and a more direct guarantee is under consideration via LWG issue 2321.
Feature-test macro | Value | Std | Feature |
---|---|---|---|
__cpp_lib_containers_ranges |
202202L |
(C++23) | Ranges-aware construction and insertion; overload (6) |
__cpp_lib_ranges_reserve_hint |
202502L |
(C++26) | ranges::approximately_sized_range and ranges::reserve_hint; overload (6) |
Example
#include <iostream> #include <string> #include <vector> template<typename T> std::ostream & operator<<(std::ostream & s, const std::vector <T>& v) { s.put('{'); for (char comma[]{'0円', ' ', '0円'}; const auto& e : v) s << comma << e, comma[0] = ','; return s << "}\n"; } int main() { // C++11 initializer list syntax: std::vector <std::string > words1{"the", "frogurt", "is", "also", "cursed"}; std::cout << "1: " << words1; // words2 == words1 std::vector <std::string > words2(words1.begin(), words1.end()); std::cout << "2: " << words2; // words3 == words1 std::vector <std::string > words3(words1); std::cout << "3: " << words3; // words4 is {"Mo", "Mo", "Mo", "Mo", "Mo"} std::vector <std::string > words4(5, "Mo"); std::cout << "4: " << words4; const auto rg = {"cat", "cow", "crow"}; #ifdef __cpp_lib_containers_ranges std::vector <std::string > words5(std::from_range, rg); // overload (6) #else std::vector <std::string > words5(rg.begin(), rg.end()); // overload (5) #endif std::cout << "5: " << words5; }
Output:
1: {the, frogurt, is, also, cursed} 2: {the, frogurt, is, also, cursed} 3: {the, frogurt, is, also, cursed} 4: {Mo, Mo, Mo, Mo, Mo} 5: {cat, cow, crow}
Defect reports
The following behavior-changing defect reports were applied retroactively to previously published C++ standards.
DR | Applied to | Behavior as published | Correct behavior |
---|---|---|---|
LWG 134 | C++98 | overload (5) allowed up to 2N copy constructor calls in the input iterator case |
changed to O(N) calls |
LWG 438 | C++98 | overload (5) would only call overload (4) if InputIt is an integral type
|
calls overload (4) if InputIt is not an LegacyInputIterator |
LWG 2193 | C++11 | the default constructor was explicit | made non-explicit |
LWG 2210 | C++11 | overload (3) did not have an allocator parameter | added the parameter |
N3346 | C++11 | for overload (3), the elements in the container were value-initialized |
they are default-inserted |