c++ - 如何使用 boost::transformed 在模板构造中使用 lambda 修改序列？

Question

我有一个 MyStruct 类型，我想从中生成一些“序列”，其中 MyStruct 的每个实例都是通过将另一个元素传递给其构造函数而生成的范围以及某些函数的输出。

函数本身 (SomeFun) 是另一个类中的成员函数，但对于本示例，我将其设为自由函数。但是，请记住，我可以简单地将它放在 lambda 中或做其他棘手的事情来避免对 lambda 的需要，因为在我的实际情况下我确实需要实际传递一个 this 指针。

这是一个简化的、可测试的版本来说明我遇到的问题:

#include <iostream>                                                             
#include <vector>                                                               
#include <boost/range/adaptor/transformed.hpp>                                  

#include <functional>                                                           

template <typename RowType>                                                     
class MyStruct;                                                                 

template <typename T>                                                           
int SomeFun(T t)                                                                
{                                                                               
    return 0;                                                                   
}                                                                               

template <typename Sequence>                                                    
using Converter = std::function<                                                
    MyStruct<typename Sequence::value_type>(                                    
        typename Sequence::value_type&)>;                                       

template <typename Sequence>                                                    
boost::transformed_range<Converter<Sequence>, Sequence>                         
    GenerateTransformedRange(const Sequence& outputs)                           
{                                                                               
    std::function<MyStruct<typename Sequence::value_type>(int)> fun =           
        [](const typename Sequence::value_type output)                          
        {                                                                       
            return MyStruct<typename Sequence::value_type>(output, SomeFun(output));
        };                                                                      

    return outputs | boost::adaptors::transformed(fun);                         
}                                                                               

// some structure                                                               
template <typename T>                                                           
struct MyStruct                                                                 
{                                                                               
    MyStruct(T t, int a)                                                        
    {                                                                           
    }                                                                           
};                                                                              

int main(int argc, const char* argv[])                                          
{                                                                               
    std::vector<int> vec {1, 2, 3};                                             

    for (auto element : GenerateTransformedRange(vec))                          
    {                                                                           
    }                                                                           

    return 0;                                                                   
}

输出结果是:

main.cpp:31:54: error: could not convert ‘boost::range_detail::operator|(const InputRng&, const boost::range_detail::transform_holder&) [with InputRng = std::vector; UnaryFunction = std::function(int)>]((*(const boost::range_detail::transform_holder(int)>

)(& boost::range_detail::forwarder::operator()(T) const [with T = std::function(int)>; Holder = boost::range_detail::transform_holder](std::function(int)>(((const std::function(int)>*)(& fun)))))))’ from ‘boost::range_detail::transformed_range(int)>, const std::vector >’ to ‘boost::range_detail::transformed_range(int&)>, std::vector >’ return outputs | boost::adaptors::transformed(fun); ^ makefile:25: recipe for target '.obj/main.o' failed

我在这里做错了什么？我不明白为什么它要从该类型转换。有任何想法吗？我正在使用 Boost 1.55。

Answer 1

错误:

test.cpp:29:20: error: no match for ‘operator|’ (operand types are ‘const std::vector’ and ‘std::function >(int)>’) return outputs | fun;

应该非常清楚。没有 operator|对于操作数 vector和一个 function .您的第二个操作数应该是一个 boost 适配器，它实际上定义了运算符。大概是这样的:

return outputs | boost::adaptors::transformed(fun);

同样在这段代码中:

std::function<MyStruct<Sequence>(int)> fun =
        [](const typename Sequence::value_type output)
        {
            return MyStruct<typename Sequence::value_type>(output, SomeFun(output));
        };

根据类型声明，fun应该返回 MyStruct<Sequence>但是你的 lambda 返回一个 MyStruct<typename Sequence::value_type> .此外，您可能不应该将参数类型硬编码为 int。如果 lambda 期望 Sequence::value_type .您可能应该声明 fun作为类型 Converter<Sequence> .此外，修复 lambda 的参数类型和函数以匹配 Converter (注意引用)。