C++ 为什么在C++；11或C++；14?

C++98有

前插入器

、

后插入器

和

插入器

，但在C++11或草稿C++14中似乎没有这些插入器的任何安放版本。是否有任何技术原因导致我们无法使用

前置机

、

后置机

和

前置机

有没有什么技术上的原因，我们不能使用前置机、后置机和前置机

不，没有技术原因。作为证明，这里有一个完整的

back\u 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;
}

#包括
#包括
#包括
模板
类back\u emplace\u iterator:public std:：iterator
{
受保护的：
集装箱*集装箱；
公众：
类型定义容器容器类型；
显式后模板迭代器（容器&x）：容器（&x）{}
模板
后模板迭代器&
运算符=（T&&T）
{
集装箱->后侵位（标准：前侵位（t））；
归还*这个；
}
后退放置迭代器和运算符*（）{return*this；}
后退放置迭代器和运算符++（）{return*this；}
返回模板迭代器和运算符++（int）{return*this；}
};
模板<类容器>
内联后插迭代器
后台员工（集装箱和集装箱）
{
返回模板迭代器（c）；
}
结构演示
{
int i；
演示（inti）：i（i）{}
};
int main（）
{
向量x={1,2,3,4,5}；
std：：向量y；
复制（x.begin（），x.end（），back_emplacer（y））；
用于（自动d:y）
std:：cout您的主要用例已经被
插入器
、
后插入器
和
前插入器
覆盖。已经有一个
值类型&&
重载的
操作符=
将移动到容器中。唯一
emplacer
可以对
插入器
执行的操作是调用显式收缩监管者

将
container:：insert
、
container:：push_back
和
container:：push_front
的常见重载与
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 );

你要给它们赋值什么？参数元组？@MooingDuck:这已经可以用了inserters@PavelAnossov：但由于插入器坚持插入容器所持有类型的对象，因此您需要支付罚款（通常是移动）用于插入不同的类型。安放可以避免这种惩罚。@沃尔特：用例1：我有一个int容器和一个objects容器，其中每个对象都可以用int初始化。我想在对象容器中附加一系列用int初始化的新对象，我想最大限度地提高效率。用例2：我有一个STL风格的算法库，但它们同时对多个输入序列进行操作（就像std:：transform的两序列版本）。我想在序列的前面添加新对象，其中新对象的n个构造函数参数取自我正在处理的n个输入序列。@Walter：插入到一个对象数组中，其中的对象是大的和/或遗留类型，可以复制但不能移动。这不完全是一个延伸。我对已知的问题有疑问。@MooIgBug：代理什么？去看看LabStdC++的实现，代码< > BuffixIdultAudio.H./COD> .@ MOOIGNEDIG:所以，C++标准要求不使用代理类，但要用它的方式来实现。参见N348 524.5.2.2.3，存在证明是很棒的：-我把它标记为ANSW。呃。谢谢你的出色工作！这比普通的
反向插入器\u迭代器
有什么优势吗？
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; }
};