Pourquoi n'y a-t-il pas d'itérateurs d'emplacement en C++11 ou C++14 ?

Question

C++98 a front_inserter , back_inserter y inserter mais il ne semble pas y avoir de versions de ces emplacements en C++11 ou dans le projet de C++14. Existe-t-il une raison technique pour laquelle nous ne pourrions pas avoir front_emplacer , back_emplacer y emplacer ?

Answer 1

Y a-t-il une raison technique pour laquelle nous ne pourrions pas avoir front_emplacer, back_emplacer et emplacer ?

Non, il n'y a pas de raison technique. Pour preuve, voici une implémentation complète de back_emplacer avec une démonstration de votre cas d'utilisation 1...

#include <iterator>
#include <vector>
#include <iostream>

template<class Container>
class back_emplace_iterator : public std::iterator< std::output_iterator_tag,
                                                   void, void, void, void >
{
protected:
    Container* container;
public:
    typedef Container container_type;

    explicit back_emplace_iterator(Container& x) : container(&x) {}

    template<class T>
    back_emplace_iterator<Container>&
    operator=(T&& t)
    {
        container->emplace_back(std::forward<T>(t));
        return *this;
    }

    back_emplace_iterator& operator*() { return *this; }
    back_emplace_iterator& operator++() { return *this; }
    back_emplace_iterator& operator++(int) { return *this; }
};

template< class Container >
inline back_emplace_iterator<Container>
back_emplacer( Container& c )
{
    return back_emplace_iterator<Container>(c);
}

struct Demo
{
    int i;
    Demo(int i) : i(i) {}
};

int main()
{
    std::vector<int> x = {1,2,3,4,5};

    std::vector<Demo> y;

    std::copy(x.begin(), x.end(), back_emplacer(y));

    for (auto d : y)
        std::cout << d.i << std::endl;
}

Problème connu possible : La référence universelle de operator= cacher une copie/déplacement générée implicitement operator= ? Dans l'affirmative, il convient de les définir explicitement de manière à surpasser la référence universelle en matière de résolution des surcharges.

Answer 2

Votre principal cas d'utilisation est déjà couvert par inserter , back_inserter y front_inserter . Il existe déjà un value_type && surcharge de operator= qui se déplacera dans le conteneur. La seule chose emplacer pourrait faire plus inserter est d'appeler des constructeurs explicites.

Comparez les surcharges courantes de container::insert , container::push_back y container::push_front a container::emplace , container::emplace_back y container::emplace_front

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

template< class... Args > 
iterator emplace( const_iterator pos, Args&&... args );

void push_back( const value_type & value );
void push_back( value_type && value );

template< class... Args >
void emplace_back( Args&&... args );

void push_front( const value_type & value );
void push_front( value_type && value );

template< class... Args >
void emplace_front( Args&&... args );

Chacun des emplace variants prend un ensemble d'arguments pour construire la valeur. operator = prend exactement un argument. Vous pouvez écrire un emplacer qui prend un tuple d'arguments.

template<class Container>
class back_emplace_iterator : public std::iterator< std::output_iterator_tag,
                                                   void, void, void, void >
{
protected:
    Container* container;
public:
    typedef Container container_type;

    explicit back_emplace_iterator(Container& x) : container(&x) {}

    template<typename ... Args>
    back_emplace_iterator<Container>&
    operator=(std::tuple<Args&&...> args)
    {
        std::apply(Container::emplace_back, std::tuple_cat(std::tie(*container), std::forward<std::tuple<Args&&...>>(args)));
        return *this;
    }

    back_emplace_iterator& operator*() { return *this; }
    back_emplace_iterator& operator++() { return *this; }
    back_emplace_iterator& operator++(int) { return *this; }
};