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

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

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

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

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

4. Constructs a list with count copies of elements with value value.

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

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

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

1. The move constructor. Constructs a list 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 list, the behavior is undefined.

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

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

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

Contents

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

[edit] Parameters

[edit] Complexity

1,2) Constant.

3,4) Linear in count.

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().

[edit] Exceptions

Calls to Allocator::allocate may throw.

[edit] 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.

[edit] Example

#include #include #include   template std::ostream& operator<<(std::ostream& s, const std::list& 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::list<std::string> words1{"the", "frogurt", "is", "also", "cursed"}; std::cout << "1: " << words1;   // words2 == words1 std::list<std::string> words2(words1.begin(), words1.end()); std::cout << "2: " << words2;   // words3 == words1 std::list<std::string> words3(words1); std::cout << "3: " << words3;   // words4 is {"Mo", "Mo", "Mo", "Mo", "Mo"} std::list<std::string> words4(5, "Mo"); std::cout << "4: " << words4;   const auto rg = {"cat", "cow", "crow"}; #ifdef __cpp_lib_containers_ranges std::list<std::string> words5(std::from_range, rg); // overload (6) #else std::list<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}

[edit] Defect reports

The following behavior-changing defect reports were applied retroactively to previously published C++ standards.

[edit] See also

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