Question

我已经阅读此网站已有一段时间了，但是刚刚注册。我还使用了搜索，但似乎没有什么帮助。

在这里是：在玩C ++的过程中，我在Internet上遇到了“惰性评估”概念。我对创建类似“惰性向量”的东西很感兴趣，该函数定义了带有N个参数和前N个向量元素的函数。

但是，我目前遇到了这个问题。让我指出一下：

template<typename T, typename... A>
class llazy
{

public:
    llazy(const std::function<T(A...)>& func, A... args) : func(func), vec({args...}), numArgs(sizeof...(args))
    {}
    const T& operator[](size_t index)
    {
        unsigned short tmp = 1;
        //Here I want to stray from 2 elements to pass to function and make the number at least like 0-4
        std::vector<size_t> v;
        for (unsigned short i = 0; i < numArgs; i++)
            v.emplace_back(vec.size() - tmp++);
        //As you can see here, there are no issues(if the vector has enough elements ofc) with these two
        unsigned long long i = vec.size() - 2, j = vec.size() - 1;
        while (vec.size() < index + 1)
            //So how do I pass all the vec[v[0]], vec[v[1]], etc... elements to the "func"?
            //Maybe there is another way to achieve this, however, this is the Python which makes me think this is possible
            vec.emplace_back(func(vec[i++], vec[j++]));
        if (vec.size() >= index + 1)
            return vec[index];
    }
private:
    const unsigned char numArgs;
    const std::function<T(A...)> func;
        std::vector<T> vec;
    };

using ullong = unsigned long long;

int main()
{
    llazy<ullong, ullong, ullong> l(std::function<ullong(ullong, ullong)>([](ullong i, ullong j) { return i + j; }), 1, 1);
    l[20];
    l[50];
    l[1000];
    return 0;
}

谢谢您的回答。

UPD：当然，可以将向量传递给函数，但是，这会使函数本身的可读性降低很多（例如，无符号和（无符号，无符号）比无符号和（std :: vector）清晰得多）

Answer 1

如何使用向量的最后N个元素作为函数参数

您不需要将这些元素放入临时向量中。

相反，经典的解决方案是使用带有std::index_sequence参数（以及索引的参数包）的单独函数（或者，如果您愿意，可以使用C ++ 20模板lambda）。通过pack扩展，您可以轻松地从向量中以一种或另一种方式提取最后N个元素。

类似的事情会起作用：

template <typename F, std::size_t ...I>
auto make_tuple_seq(std::index_sequence<I...>, F &&func)
{
    return std::tuple{func(I)...};
}

int main()
{
    std::vector v = {1,2,3,4,5,6};
    const int n = 3;
    auto t = make_tuple_seq(std::make_index_sequence<n>{}, 
                            [&](std::size_t i) {return v[v.size() - n + i];});

    // Prints `456`.
    std::cout << std::apply([](int x, int y, int z){return x*100 + y*10 + z;}, t) << '\n';
}

根据您的需求调整此代码应该不难。

如何在C ++中将向量的最后N个元素用作函数参数？

1 个答案: