Home - News ( United States | United Kingdom | Italy | Germany ) - Football scores

Showing content from https://en.cppreference.com/w/cpp/language/../container/deque/insert.html below:

std::deque<T,Allocator>::insert - cppreference.com

iterator insert( const_iterator pos, const T& value );

iterator insert( const_iterator pos, T&& value );

iterator insert( const_iterator pos,
                 size_type count, const T& value );

template< class InputIt >
iterator insert( const_iterator pos, InputIt first, InputIt last );

Inserts elements at the specified location in the container.

1) Inserts a copy of value before pos.

If any of the following conditions is satisfied, the behavior is undefined:

• T is not CopyAssignable.

2) Inserts value before pos, possibly using move semantics.

3) Inserts count copies of the value before pos.

If any of the following conditions is satisfied, the behavior is undefined:

• T is not CopyAssignable.

Inserts elements from range

before

.

This overload has the same effect as overload (3) if InputIt is an integral type.

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:

• first or last are iterators into *this.

5) Inserts elements from initializer list ilist before pos.

Equivalent to insert(pos, ilist.begin(), ilist.end()).

All iterators (including the end() iterator) are invalidated. References are invalidated too, unless pos == begin() or pos == end(), in which case they are not invalidated.

1,2) Iterator pointing to the inserted value.

3-5) Iterator pointing to the first element inserted, or pos if no element is inserted.

Linear in the number of elements inserted plus std::min(std::distance(begin(), pos), std::distance(pos, end())).

If an exception is thrown other than by

• the copy constructor of T,

• the move constructor of T,

• the copy assignment operator of T,

• the move assignment operator of T,

this function has no effect (strong exception guarantee).

If an exception is thrown when inserting a single element at either end, this function has no effect (strong exception guarantee). Otherwise, if an exception is thrown by the move constructor of a non-CopyInsertable T, the effects are unspecified.

#include <iostream>
#include <iterator>
#include <string_view>
#include <deque>
 
namespace stq
{
    void println(std::string_view rem, const std::deque<int>& container)
    {
        std::cout << rem.substr(0, rem.size() - 2) << '[';
        bool first{true};
        for (const int x : container)
            std::cout << (first ? first = false, "" : ", ") << x;
        std::cout << "]\n";
    }
}
 
int main()
{
    std::deque<int> c1(3, 100);
    stq::println("1. {}", c1);
 
    auto pos = c1.begin();
    pos = c1.insert(pos, 200); // overload (1)
    stq::println("2. {}", c1);
 
    c1.insert(pos, 2, 300); // overload (3)
    stq::println("3. {}", c1);
 
    // reset pos to the begin:
    pos = c1.begin();
 
    std::deque<int> c2(2, 400);
    c1.insert(std::next(pos, 2), c2.begin(), c2.end()); // overload (4)
    stq::println("4. {}", c1);
 
    int arr[] = {501, 502, 503};
    c1.insert(c1.begin(), arr, arr + std::size(arr)); // overload (4)
    stq::println("5. {}", c1);
 
    c1.insert(c1.end(), {601, 602, 603}); // overload (5)
    stq::println("6. {}", c1);
}

Output:

1. [100, 100, 100]
2. [200, 100, 100, 100]
3. [300, 300, 200, 100, 100, 100]
4. [300, 300, 400, 400, 200, 100, 100, 100]
5. [501, 502, 503, 300, 300, 400, 400, 200, 100, 100, 100]
6. [501, 502, 503, 300, 300, 400, 400, 200, 100, 100, 100, 601, 602, 603]

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

RetroSearch is an open source project built by @garambo | Open a GitHub Issue

Search and Browse the WWW like it's 1997 | Search results from DuckDuckGo

HTML: 3.2 | Encoding: UTF-8 | Version: 0.7.4