Question

我有几个函数

struct ins;
enum class op_t {
    // ...
};

std::vector<ins> optimise_addone(std::vector<ins> prog)
{
    for (size_t i = 0; i < prog.size() - 1; i++) {
        auto &a = prog[i];
        auto &b = prog[i + 1];
        if (a.code == op_t::SET && a.op.which() == 1 && boost::get<uint16_t>(a.op) == 1 && b.code == op_t::ADD) {
            a = make_ins(op_t::INC);
            prog.erase(prog.begin() + i + 1);
            i += 1;
        }
    }
    return prog;
}

std::vector<ins> optimise_storeload(std::vector<ins> prog)
{
    for (size_t i = 0; i < prog.size() - 3; i++) {
        auto &a = prog[i];
        auto &b = prog[i + 1];
        auto &c = prog[i + 2];
        auto &d = prog[i + 3];
        if (a.code == op_t::SET && c.code == op_t::SET && b.code == op_t::STORE && d.code == op_t::LOAD && a.op == c.op) {
            a = make_ins(op_t::DUP);
            b = make_ins(op_t::SET, c.op);
            c = make_ins(op_t::STORE);
            prog.erase(prog.begin() + i + 3);
            i += 3;
        }
    }
    return prog;
}

它们各自接受一个向量，找到它的一个修补小节（大小为N），并以某种任意方式修改它

在我看来，应该有一种方法可以使用模板或函数对象或类似方法来推广它，但我自己也看不到它。

最好的方法是什么？

Answer 1

高阶函数很好地解决了您的问题。下面是C ++ 14解决方案。

以下是最终界面的外观：

std::vector<int> v{1, 2, 3, 4, 5};
patchVector<2>(v, [](auto& a, auto& b){
    std::cout << a + b << " ";
});

打印：

3 5 7 9

template <typename Vector, typename F, std::size_t... Is>
auto callWithSlice(std::size_t i, Vector& v, F&& f, std::index_sequence<Is...>)
{
    return f(v[i + Is]...);
}

template <std::size_t N, typename Vector, typename F>
auto patchVector(Vector v, F&& f)
{
    for(std::size_t i = 0; i < v.size() - N + 1; ++i)
    {
        callWithSlice(i, v, std::forward<F>(f), std::make_index_sequence<N>{});
    }
}

live wandbox example

C ++向量上的模式匹配

1 个答案: