是 back_insert_iterator<>按值传递安全吗？

Question

我有一个看起来像这样的代码：

struct Data { int value; };
class A {
public:
    typedef std::deque<boost::shared_ptr<Data> > TList;
    std::back_insert_iterator<TList> GetInserter()
    {
        return std::back_inserter(m_List);
    }
private:
    TList m_List;
};
class AA {
    boost::scoped_ptr<A> m_a;
public:
    AA() : m_a(new A()) {}
    std::back_insert_iterator<A::TList> GetDataInserter()
    {
        return m_a->GetInserter();
    }        
};
class B {
    template<class OutIt>
    CopyInterestingDataTo(OutIt outIt)
    {
        // loop and check conditions for interesting data
        // for every `it` in a Container<Data*>
        // create a copy and store it
        for( ... it = ..; .. ; ..) if (...) {
            *outIt = OutIt::container_type::value_type(new Data(**it));
            outIt++; // dummy
        }
    }
    void func()
    {
        AA aa;
        CopyInterestingDataTo(aa.GetDataInserter());
        // aa.m_a->m_List is empty!
    }
};

问题是，即使在调用 CopyInterestingDataTo() 后，A::m_List 也始终为空。但是，如果我调试并进入 CopyInterestingDataTo()，迭代器确实会存储所谓插入的数据！

更新： 我找到了罪魁祸首。我实际上有这样的想法：

class AA {
    boost::scoped_ptr<A> m_a;
    std::back_insert_iterator<A::TList> GetDataInserter()
    {
        //return m_a->GetInserter(); // wrong
        return m_A->GetInserter(); // this is the one I actually want
    }        
    // ..... somewhere at the end of the file
    boost::scoped_ptr<A> m_A;
};

现在，我应该将哪个答案标记为答案？ 对于那些没有被选中的人真的很抱歉，但是你们肯定得到了一些赞成票:)

Answer 1

简短的回答是肯定的，back_insert_iterator 可以安全地按值传递。长答案：来自标准 24.4.2/3：

插入迭代器满足
输出迭代器的要求。

和24.1.2/1

A类或内置类型X满足
输出迭代器的要求
如果 X 是可分配类型 (23.1) ...

最后来自 23.1 中的表 64：

表达式 t = u
返回类型 T&
后置条件 t 相当于 u

编辑： 乍一看，您的代码对我来说没问题，您是否 100% 确定元素确实被插入？如果您是，我将单步执行代码并检查 aa.m_a->m_List 对象的地址，并将其与 outIt 中存储的地址进行比较>CopyInterestingDataTo，如果它们不相同，则有些可疑。

Answer 2

以下代码编译后打印“1”，表示已将一项添加到列表中：

#include <iostream>
#include <deque>
#include "boost/shared_ptr.hpp"
#include "boost/scoped_ptr.hpp"

struct Data { 
    int value; 
    Data( int n ) : value(n) {}
};

struct A {
    typedef std::deque<boost::shared_ptr<Data> > TList;
    std::back_insert_iterator<TList> GetInserter()
    {
        return std::back_inserter(m_List);
    }
    TList m_List;
};

struct AA {
    boost::scoped_ptr<A> m_a;
    AA() : m_a(new A()) {}
    std::back_insert_iterator<A::TList> GetDataInserter()
    {
        return m_a->GetInserter();
    }        
};

struct B {
    template<class OutIt>
    void CopyInterestingDataTo(OutIt outIt)
    {
        *outIt = typename OutIt::container_type::value_type(new Data(0));
        outIt++; // dummy
    }
    int func()
    {
        AA aa;
        CopyInterestingDataTo(aa.GetDataInserter());
        return aa.m_a->m_List.size();
    }
};

int main() {
    B b;
    int n = b.func();    
    std::cout <<  n << std::endl;
}