我有一个算法，给定任意数量的向量运行特定算法并返回结果。
矢量可以从输入文件中读取，其中行代表csv格式的向量，或者用户可以指定正整数（大于2）n，k，m，程序将生成n个向量，其中每个k坐标随机分布在[0，m-1]范围内。
用户可以在几个可以应用于每个矢量的函数之间进行选择，例如，每个函数乘以标量，将模数应用于每个元素，将第N个坐标调零等。
我正在考虑的解决方案是使用迭代器，就像标准算法一样（例如std::copy）
template<class InputIt>
int my_transform(InputIt begin, InputIt end){
// ... stuff from begin to end
return result;
}
虽然我使用std::istream_iterator作为参数时有效，但我完全相信我会使用boost::function_input_iterator生成值并使用boost::transform_iterator来应用所需的函数I我不太确定如何根据用户输入在运行时制作这些组合。
我可以在执行my_transform之前聚合所有用户输入，但是我如何将其应用于生成的迭代器，因为它可以是从std::istream_iterator到boost::transform_iterator的任何内容boost::function_input_iterator？
P.S：
答案 0 :(得分：1)
我想你想要Boost Range的
join any_range（基于any_terator）或许你可以重新设计算法，默认情况下在“流”模式下工作，也可以动态写入输出迭代器。
这是一个示例，演示如何连接任何输入范围组合（不同类型），然后在其组合元素上应用任何变换函数序列。
主程序如下：
int main(int argc, char const** argv) {
using InIt = std::istream_iterator<int>;
if (argc!=4) return 255;
std::ifstream f1(argv[1]), f2(argv[2]), f3(argv[3]);
auto r1 = boost::make_iterator_range(InIt(f1), {}),
r2 = boost::make_iterator_range(InIt(f2), {}),
r3 = boost::make_iterator_range(InIt(f3), {});
auto r4 = boost::make_iterator_range(boost::make_function_input_iterator(r10gen_, 0), { r10gen_, 10 });
srand(time(0));
for (int i : random_compose_input(r1,r2,r3,r4)
| transformed(random_transform(
[](int i) { return i/3; },
[](int i) { return -4*i; },
[](int i) { return 100+i; },
[](int i) { return sqrt(abs(i)); }
))
)
{
std::cout << i << " ";
}
}
函数random_compose_input和random_transform执行运行时选择输入范围和转换函数。
random_compose_input会返回any_range，其中包含所选组合的推断类型的连接范围：
/////////////////////////////////////////////
// runtime composition of any input ranges
using AnyR = boost::any_range<int const, boost::single_pass_traversal_tag, int>;
template <typename R1, typename R2, typename R3, typename R4>
AnyR random_compose_input(R1 const& r1, R2 const& r2, R3 const& r3, R4 const& r4)
{
int select = rand()%16;
std::cout << "selected inputs " << std::showbase << std::hex << select << std::dec << "\n";
switch(select) {
case 0:
static int const* dummy = nullptr;
return boost::make_iterator_range(dummy, dummy);
case 1: return multi_join(r1 );
case 2: return multi_join( r2 );
case 3: return multi_join(r1, r2 );
case 4: return multi_join( r3 );
case 5: return multi_join(r1, r3 );
case 6: return multi_join( r2, r3 );
case 7: return multi_join(r1, r2, r3 );
case 8: return multi_join( r4);
case 9: return multi_join(r1, r4);
case 10: return multi_join( r2, r4);
case 11: return multi_join(r1, r2, r4);
case 12: return multi_join( r3, r4);
case 13: return multi_join(r1, r3, r4);
case 14: return multi_join( r2, r3, r4);
case 15: return multi_join(r1, r2, r3, r4);
}
throw "oops";
}
注意 multi_join是join的用武之地。请参阅使用可变参数函数模板（直接）实现的完整程序列表。
random_transform组成恰好boost::function<int(int)>：
/////////////////////////////////////////////
// random composition of transformation
using Xfrm = boost::function<int(int)>;
template <typename F1, typename F2, typename F3, typename F4>
Xfrm random_transform(F1 const& f1, F2 const& f2, F3 const& f3, F4 const& f4)
{
int select = rand()%16;
std::cout << "selected transforms " << std::showbase << std::hex << select << std::dec << "\n";
switch(select) {
case 0: return [=](int i){ return ( ( ( (i)))); };
case 1: return [=](int i){ return ( ( (f1(i)))); };
case 2: return [=](int i){ return ( (f2( (i)))); };
case 3: return [=](int i){ return ( (f2(f1(i)))); };
case 4: return [=](int i){ return (f3( ( (i)))); };
case 5: return [=](int i){ return (f3( (f1(i)))); };
case 6: return [=](int i){ return (f3(f2( (i)))); };
case 7: return [=](int i){ return (f3(f2(f1(i)))); };
case 8: return [=](int i){ return f4( ( ( (i)))); };
case 9: return [=](int i){ return f4( ( (f1(i)))); };
case 10: return [=](int i){ return f4( (f2( (i)))); };
case 11: return [=](int i){ return f4( (f2(f1(i)))); };
case 12: return [=](int i){ return f4(f3( ( (i)))); };
case 13: return [=](int i){ return f4(f3( (f1(i)))); };
case 14: return [=](int i){ return f4(f3(f2( (i)))); };
case 15: return [=](int i){ return f4(f3(f2(f1(i)))); };
}
throw "oops";
}
对于样本，我已经硬编码了4个输入范围和4个潜在的转换步骤。
但如果您愿意，可以随时以“空白”AnyR或boost::function<int(int)>开头：
boost::function<int(int)> xfrm = [](int i){return i;};
while (std::getline(std::cin, line))
{
if (line == "+2") xfrm = [=](int i) { return xfrm(i) + 2 };
else if (line == "-2") xfrm = [=](int i) { return xfrm(i) - 2 };
else if (line == "*2") xfrm = [=](int i) { return xfrm(i) * 2 };
else if (line == "/2") xfrm = [=](int i) { return xfrm(i) / 2 };
}
（注意行为与静态已知lambdas组成的细微差别：lambda具有推导的返回类型（例如double为sqrt(abs(i))），并保持类型。由于boost::function会删除此信息，因此它会隐式强制转换序列中的每一步int。）
这里有两个库错误：
另一个不知道的错误，any_iterator无法在添加构造函数重载时无法包裹function_input_iterator：
function_input_iterator(base_type const& b) : base_type(b) {};
这是因为在某些时候any_iterator继续只使用基类（这应该可以在function_input_iterator库中修复。
由于上面提到的错误，它并没有完全在Coliru上运行，但是这是一个完整的程序，可以编译我的GCC并在c ++ 11模式下进行clang安装：
<强> Live On Coliru
#include <boost/function.hpp>
#include <boost/range.hpp>
#include <boost/range/adaptors.hpp>
#include <boost/range/any_range.hpp>
#include <boost/range/join.hpp>
#include <boost/iterator/function_input_iterator.hpp>
using namespace boost::adaptors;
#include <iostream>
#include <fstream>
#include <vector>
/////////////////////////////////////////////
// multi_join utility
namespace detail {
struct multi_join_dispatch {
template <typename R1> static R1 call(R1&& r1)
{ return std::forward<R1>(r1); }
template <typename R1, typename... Rs> static auto call(R1&& r1, Rs&&... ranges)
-> decltype(boost::range::join(std::forward<R1>(r1), call(std::forward<Rs>(ranges)...)))
{ return boost::range::join(std::forward<R1>(r1), call(std::forward<Rs>(ranges)...)); }
};
}
template <typename... Rs> auto multi_join(Rs&&... ranges)
-> decltype(detail::multi_join_dispatch::call(std::forward<Rs>(ranges)...))
{ return detail::multi_join_dispatch::call(std::forward<Rs>(ranges)...); }
/////////////////////////////////////////////
// generate random numbers [0..9]
struct r10gen {
typedef int result_type;
int operator()() const { return rand()%10; }
} static r10gen_;
/////////////////////////////////////////////
// runtime composition of any input ranges
using AnyR = boost::any_range<int const, boost::single_pass_traversal_tag, int>;
template <typename R1, typename R2, typename R3, typename R4>
AnyR random_compose_input(R1 const& r1, R2 const& r2, R3 const& r3, R4 const& r4)
{
int select = rand()%16;
std::cout << "selected inputs " << std::showbase << std::hex << select << std::dec << "\n";
switch(select) {
case 0:
static int const* dummy = nullptr;
return boost::make_iterator_range(dummy, dummy);
case 1: return multi_join(r1 );
case 2: return multi_join( r2 );
case 3: return multi_join(r1, r2 );
case 4: return multi_join( r3 );
case 5: return multi_join(r1, r3 );
case 6: return multi_join( r2, r3 );
case 7: return multi_join(r1, r2, r3 );
case 8: return multi_join( r4);
case 9: return multi_join(r1, r4);
case 10: return multi_join( r2, r4);
case 11: return multi_join(r1, r2, r4);
case 12: return multi_join( r3, r4);
case 13: return multi_join(r1, r3, r4);
case 14: return multi_join( r2, r3, r4);
case 15: return multi_join(r1, r2, r3, r4);
}
throw "oops";
}
/////////////////////////////////////////////
// random composition of transformation
using Xfrm = boost::function<int(int)>;
template <typename F1, typename F2, typename F3, typename F4>
Xfrm random_transform(F1 const& f1, F2 const& f2, F3 const& f3, F4 const& f4)
{
int select = rand()%16;
std::cout << "selected transforms " << std::showbase << std::hex << select << std::dec << "\n";
switch(select) {
case 0: return [=](int i){ return ( ( ( (i)))); };
case 1: return [=](int i){ return ( ( (f1(i)))); };
case 2: return [=](int i){ return ( (f2( (i)))); };
case 3: return [=](int i){ return ( (f2(f1(i)))); };
case 4: return [=](int i){ return (f3( ( (i)))); };
case 5: return [=](int i){ return (f3( (f1(i)))); };
case 6: return [=](int i){ return (f3(f2( (i)))); };
case 7: return [=](int i){ return (f3(f2(f1(i)))); };
case 8: return [=](int i){ return f4( ( ( (i)))); };
case 9: return [=](int i){ return f4( ( (f1(i)))); };
case 10: return [=](int i){ return f4( (f2( (i)))); };
case 11: return [=](int i){ return f4( (f2(f1(i)))); };
case 12: return [=](int i){ return f4(f3( ( (i)))); };
case 13: return [=](int i){ return f4(f3( (f1(i)))); };
case 14: return [=](int i){ return f4(f3(f2( (i)))); };
case 15: return [=](int i){ return f4(f3(f2(f1(i)))); };
}
throw "oops";
}
int main(int argc, char const** argv) {
using InIt = std::istream_iterator<int>;
if (argc!=4) return 255;
std::ifstream f1(argv[1]), f2(argv[2]), f3(argv[3]);
auto r1 = boost::make_iterator_range(InIt(f1), {}),
r2 = boost::make_iterator_range(InIt(f2), {}),
r3 = boost::make_iterator_range(InIt(f3), {});
auto fi_b = boost::make_function_input_iterator(r10gen_, 0);
auto fi_l = boost::make_function_input_iterator(r10gen_, 10);
auto r4 = boost::make_iterator_range(fi_b, fi_l);
srand(time(0));
for (int i : random_compose_input(r1,r2,r3,r4)
| transformed(random_transform(
[](int i) { return i/3; },
[](int i) { return -4*i; },
[](int i) { return 100+i; },
[](int i) { return sqrt(abs(i)); }
))
)
{
std::cout << i << " ";
}
}
当我用例如
运行时watch ./test <(echo {100..110}) <(echo {200..220}) <(echo {300..330})
典型输出
selected transforms 0x3
selected inputs 0x2
-264 -268 -268 -268 -272 -272 -272 -276 -276 -276 -280 -280 -280 -284 -284 -284 -288 -288 -288 -292 -292
或者，例如
selected transforms 0x1
selected inputs 0x8
0 0 2 2 0 1 2 1 1 2