C++ 具有唯一映射的变换迭代器

我有一个

Holder

类，它应该只公开其映射的值。我使用了一个转换迭代器来实现这一点。如果我使用指向类型（ClassA*）的普通指针，但不使用unique_ptr，它就可以工作。我将以下示例基于此代码：

我得到了以下错误（源于

begin（）

函数），这让我认为有人试图复制该对，而不是使用引用

提前谢谢

错误C2248:
“

std:：unique\u ptr:：unique\u ptr

”：
无法访问类中声明的私有成员
“

std:：unique\u ptr

”

#包括
#包括
#包括
#包括
#包括
#包括
结构类A
{
ClassA（const std:：string和strName）：m_strName（strName）{}
std：：字符串m_strName；
};
模板
const V&get_值（std:：pair const&p）{return p.second；}
阶级持有者
{
typedef std:：map>TMap；
typedef std:：unique_ptrUniqueA；
TMap m_图；
公众：
持有人（）
{
UniqueA a（新a类（“#2#”）；
UniqueA b（新类别A（“#3#”）；
UniqueA c（新A类（“#4#”）；
m_Map.insert（std:：make_pair（2，std:：move（a））；
m_Map.insert（std:：make_pair（3，std:：move（b））；
m_Map.insert（std:：make_pair（4，std:：move（c））；
}
typedef std:：functionF；
typedef boost:：transform_iterator transform_iterator；
变换迭代器begin（）
{
返回boost:：make_transform_迭代器（m_Map.begin（），&get_value>）；
}
transform_迭代器end（）
{
返回boost:：make_transform_迭代器（m_Map.end（），&get_value>）；
}
};
void MyTest（）
{
支架bla；
auto s_beg=bla.begin（）；
自动s_end=bla.end（）；
用于（自动t=s_beg；t！=s_end；++t）{
std:：cout m_strName问题是
get_value
引用了
pair
，但是被传递了一个映射值类型
pair
的引用。这需要转换，需要将密钥和值复制到一个新的对。出现错误是因为
unique\u ptr
无法复制

解决方案1：更改
get\u value
以接受对
pair
的引用以匹配
TMap:：value\u type
。这允许函数直接接受对映射值的引用

解决方案2：为
const int
实例化
get\u值，而不是
int
；这将与解决方案1具有相同的效果

解决方案3：为
const unique\u ptr&
实例化
get\u value
，而不是
unique\u ptr
，这样它就需要一个包含对映射值引用的对。可以创建这个临时对，而无需在报告错误的哪一行复制
unique\u ptr
。解决方案1起作用了（我没有检查其他人）！谢谢你救了我一天。
#include <iostream>
#include <map>
#include <functional>
#include <memory>
#include <string>
#include <boost/iterator/transform_iterator.hpp>

struct ClassA
{
    ClassA( const std::string& strName ) : m_strName( strName ) {}
    std::string m_strName;
};

template <typename K, typename V>
const V & get_value(std::pair<K, V> const & p)  { return p.second; }

class Holder
{
    typedef std::map<int, std::unique_ptr< ClassA > > TMap;
    typedef std::unique_ptr< ClassA > UniqueA;
    TMap m_Map;
public:
    Holder()
    {
        UniqueA a( new ClassA( "#2# ") );
        UniqueA b( new ClassA( "#3# ") );
        UniqueA c( new ClassA( "#4# ") );
        m_Map.insert( std::make_pair( 2, std::move( a ) ) );
        m_Map.insert( std::make_pair( 3, std::move( b ) ) );
        m_Map.insert( std::make_pair( 4, std::move( c ) ) );
    }
    typedef std::function< const TMap::mapped_type & (const TMap::value_type &) > F;
    typedef boost::transform_iterator<F, TMap::iterator> transform_iterator;

    transform_iterator begin()
    {
        return boost::make_transform_iterator(m_Map.begin(), &get_value< int, std::unique_ptr< ClassA > >);
    }
    transform_iterator end()
    {
        return boost::make_transform_iterator(m_Map.end(), &get_value< int, std::unique_ptr< ClassA > >);
    }
};

void MyTest()
{
    Holder bla;
    auto s_beg = bla.begin();
    auto s_end = bla.end();
    for( auto t=s_beg; t!=s_end;++t) {
        std::cout << ( *t )->m_strName << std::endl;
    }
}