为什么 C++11 或 C++14 中没有位置迭代器？答案

【问题标题】：Why no emplacement iterators in C++11 or C++14?为什么 C++11 或 C++14 中没有位置迭代器？
【发布时间】：2013-09-14 12:31:43
【问题描述】：

C++98 有 front_inserter、back_inserter 和 inserter，但在 C++11 或草案 C++14 中似乎没有这些的任何安装版本。有什么技术原因我们不能拥有front_emplacer、back_emplacer 和emplacer？

【问题讨论】：

你要分配给他们什么？参数元组？
@MooingDuck：这已经适用于插入器
@PavelAnossov：但是由于插入器坚持插入容器所持有类型的对象，因此您为插入不同类型的对象付出了代价（通常是移动）。安置将避免这种惩罚。
@Walter：用例 1：我有一个整数容器和一个对象容器，其中每个对象都可以用一个整数初始化。我想将一系列用整数初始化的新对象附加到对象容器中，并且我想最大限度地提高效率。用例 2：我有一个 STL 风格的算法库，但它们一次对多个输入序列进行操作（如 std::transform 的双序列版本）。我想将新对象添加到序列的前面，其中新对象的 n 个构造函数参数取自我正在处理的 n 个输入序列。
@Walter：插入对象数组，其中对象很大和/或可复制但不可移动的旧类型。这并不完全是一个延伸。

标签： c++ c++11 stl iterator c++14

【解决方案1】：

我们不能有front_emplacer、back_emplacer和emplacer有什么技术原因吗？

不，没有技术原因。作为证明，这里是 back_emplacer 的完整实现以及您的用例 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;
}

可能的已知问题：operator= 的通用引用是否隐藏了隐式生成的复制/移动 operator=？如果是这样，则需要以优于重载决议中的通用引用的方式明确定义这些。

【讨论】：

关于已知问题我有asked another question。
@MooingDuck：代理类有什么用？去看看 back_inserter 的 libstdc++ 实现。它位于bits/stl_iterator.h。
@MooingDuck：因此 C++ 标准要求不使用代理类，而是按照所示方式实现它。见 N3485 24.5.2.2.3。
这比普通的back_inserter_iterator有优势吗？ stackoverflow.com/questions/54303852/…
@alfC：是的，我现在认为back_emplace_iterator 的概念在概念上存在缺陷。 “emplace”风格的操作接受一组参数，然后将它们转发给构造函数。参见例如std::vector::emplace_back。这样的操作不适合迭代器范式，因为底层迭代器抽象不支持它。

【解决方案2】：

inserter、back_inserter 和 front_inserter 已经涵盖了您的主要用例。已经有 operator= 的 value_type && 重载将移动到容器中。 emplacer 唯一能对 inserter 做的就是调用显式构造函数。

比较container::insert、container::push_back和container::push_front与container::emplace、container::emplace_back和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 );

每个emplace 变体都采用一组参数来构造值。 operator = 只接受一个参数。你可以写一个带有参数元组的emplacer。

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; }
};

【讨论】：