std::vector<T,Allocator>::vector - cppreference.com (original) (raw)

Constructs a new vector from a variety of data sources, optionally using a user supplied allocator alloc.

1. The default constructor since C++11. Constructs an empty vector with a default-constructed allocator.

2. The default constructor until C++11. Constructs an empty vector with the given allocator alloc.

3. Constructs a vector with count default-inserted objects of T. No copies are made.

If T is not DefaultInsertable into vector, the behavior is undefined.

1. Constructs a vector with count copies of elements with value value.

1. Constructs a vector with the contents of the range [first, last). Each iterator in [first, last) is dereferenced exactly once.

1. Constructs a vector with the contents of the range rg. Each iterator in rg is dereferenced exactly once.

2. The copy constructor. Constructs a vector with the contents of other.

1. The move constructor. Constructs a vector with the contents of other. The allocator is obtained by move construction from other.get_allocator().

2. Same as the copy constructor, except that alloc is used as the allocator.

If T is not CopyInsertable into vector, the behavior is undefined.

1. Same as the move constructor, except that alloc is used as the allocator.

If T is not MoveInsertable into vector, the behavior is undefined.

1. Equivalent to vector(il.begin(), il.end(), alloc).

Contents

• 1 Parameters
• 2 Complexity
• 3 Exceptions
• 4 Notes
• 5 Example
• 6 Defect reports
• 7 See also

Parameters

Complexity

1,2) Constant.

3,4) Linear in count.

1. Given std::distance(first, last) as \(\scriptsize N \)N:

• If InputIt satisfies the requirements of LegacyForwardIterator, then:

• The copy constructor of T is only called \(\scriptsize N \)N times.

• No reallocation occurs.

• Otherwise:

• The copy constructor of T is called \(\scriptsize O(N) \)O(N) times.

• Reallocation occurs \(\scriptsize O(\log N) \)O(log N) times.

1. Given ranges::distance(rg) as \(\scriptsize N \)N:

• 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.

1. Linear in other.size().

2. Constant.

3. Linear in other.size().

4. Linear in other.size() if alloc != other.get_allocator(), otherwise constant.

5. Linear in init.size().

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.

Example

#include #include #include   template std::ostream& operator<<(std::ostream& s, const std::vector& 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.

See also

| | assigns values to the container (public member function) [edit] | | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | | | assigns values to the container (public member function) [edit] |