C++ 将迭代器返回到boost适配器转换容器

我想为类的用户提供在成员容器上进行迭代的可能性，但要对元素应用转换。Boost适配器似乎非常适合转换容器，但我不知道如何将其应用到我的用例中

该函数返回一个包含开始和结束迭代器的IterPair模板，它在不进行转换的情况下工作。然而，通过转换，我将返回一对局部变量的迭代器。 无法将转换后的容器设为成员，因为它没有默认构造函数

class A
{
public:
    IterPair get_elems()
    {
          auto tr_vect =  vect_ | boost::adaptors::transformed(std::mem_fn(&std::string::c_str));
          return {std::begin(tr_vect), std::end(tr_vect)};
    }
private:
    std::vector<std::string> vect_;
}

A类
{
公众：
IterPair get_elems（）
{
auto tr_vect=vect_124;boost:：adapters:：transformed（std:：mem_fn（&std:：string:：c_str））；
返回{std:：begin（tr_vect），std:：end（tr_vect）}；
}
私人：
std：：向量向量；
}

我只需返回范围，并将其留给用户调用begin/end（或使用范围，如下例所示）：

#包括
#包括
#包括
#包括
#包括
#包括
甲级{
公众：
A（std:：initializer_list xs）：vect_{std:：move（xs）}{
//自动返回类型需要c++14
自动获取元素（）常量{
返回向量|
boost:：adapters:：transformed（std:：mem_-fn（&std:：string:：c_-str））；
}
私人：
std：：向量向量；
};
int main（int argc，字符**argv）{
A A{“A”、“ab”、“abc”}；
自动xs=a.get_elems（）；
for（const auto&x:xs）{
std：：cout我认为您可能没有正确地处理此问题……我将提供以下方法，而不是您编写的方法，这实在是太多的代码，无法在一篇快速文章中充实：

template <typename CONTAINER, // your underlying container
          typename TRANSFORM> // functor for your transform
class transform_adaptor
{
    template <typename IT = typename CONTAINER::iterator>
    class proxy_iterator : private TRANSFORM {
        // standard iterator typedefs, sourced from CONTAINER::iterator

        typedef IT underlying_iterator;
        underlying_iterator i;
     public:
        auto operator * () const -> decltype(TRANSFORM{}(*i))
        {
            return this->operator () (*i);
        }
        // Other proxy functions for the underlying iterator,
        // i.e. operator++, etc
    }

    CONTAINER * cptr;
 public:
    typedef proxy_iterator iterator;
    typedef proxy_iterator const_iterator;
    // necessary value_type, iterator, allocator, etc adaptors here

    iterator begin() { return proxy_iterator(cptr->begin()); }
    iterator end() { return proxy_iterator(cptr->end()); }
};

template//变换的函子
类转换适配器
{
模板
类代理迭代器：私有转换{
//标准迭代器typedefs，源于CONTAINER:：iterator
键入定义它的基础迭代器；
底层迭代器i；
公众：
自动运算符*（）const->decltype（转换{}（*i））
{
返回此->运算符（）（*i）；
}
//基础迭代器的其他代理函数，
//即运算符++等
}
集装箱*cptr；
公众：
typedef代理迭代器迭代器；
typedef代理迭代器const迭代器；
//必要的值类型、迭代器、分配器等适配器
迭代器begin（）{return proxy_迭代器（cptr->begin（））；}
迭代器end（）{return proxy_迭代器（cptr->end（））；}
};

很抱歉，我几乎没有勾勒出这篇文章的要点，但事实证明，它的代码比我现在希望编译和测试的代码多得多

其思想是创建一个包装容器类，该类包含对底层容器的迭代器代理以及对底层容器的引用（指针）。当使用代理迭代器的运算符*取消引用该迭代器时，它将对底层容器元素应用转换并返回其结果

这其中的不足之处在于，它破坏了某些操作的STL API，就像
std:：vector
破坏了东西一样-如果不进行更多的黑客操作，并且保证可以将传输的结果类型反向映射回原始数据域，就无法将元素从代理迭代器句柄分配回容器中（即，您的转换是1对1，或双射）。因此，某些操作（如std:：sort）将在代理容器上失败，但如果您需要一个常量容器在两个不同的api之间移动数据，则它无疑是数据转换的一个好选项

template <typename CONTAINER, // your underlying container
          typename TRANSFORM> // functor for your transform
class transform_adaptor
{
    template <typename IT = typename CONTAINER::iterator>
    class proxy_iterator : private TRANSFORM {
        // standard iterator typedefs, sourced from CONTAINER::iterator

        typedef IT underlying_iterator;
        underlying_iterator i;
     public:
        auto operator * () const -> decltype(TRANSFORM{}(*i))
        {
            return this->operator () (*i);
        }
        // Other proxy functions for the underlying iterator,
        // i.e. operator++, etc
    }

    CONTAINER * cptr;
 public:
    typedef proxy_iterator iterator;
    typedef proxy_iterator const_iterator;
    // necessary value_type, iterator, allocator, etc adaptors here

    iterator begin() { return proxy_iterator(cptr->begin()); }
    iterator end() { return proxy_iterator(cptr->end()); }
};