C++ 在c+中传递子向量作为函数参数+；

给定一个大小为10的向量v1，我想将v1的第1、第3和第7个元素作为单个函数参数传递。除了创建另一个向量v2，通过值从v1复制三个元素并传递v2的引用，还有没有更有效的方法来传递参数（即不创建v2并通过值复制元素）？

您可以将索引与向量一起传递：

std::vector<unsigned> indices = { 1, 3, 5 };


void f(const std::vector<int>& X, const std::vector<unsigned>& idx)
{
    // Do something
}

std:：vector index={1,3,5}；
空f（常数std:：vector&X，常数std:：vector&idx）
{
//做点什么
}

根据所需的行为，您可以传递

向量或以下内容的其他容器：

#包括
#包括
void f（std:：vector）{}
void g（）{
std：：向量v（10）；
f（{v[0]，v[2]，v[6]}）；
}
你说你不想创建一个新的向量并将所需的元素复制到它-那么一个带有指向3个元素指针的新向量呢？或者是一个指向元素指针的元组

std::vector<Element> items { e0, e1, e2, e3, e4, e5, e6, e7 };
auto tuple = std::make_tuple(&items[0], &items[2], &items[6]);

std:：向量项{e0、e1、e2、e3、e4、e5、e6、e7}；
auto tuple=std:：make_tuple（&items[0]、&items[2]、&items[6]）；

或者只是一个带有3个字段的自定义参数结构-指向3个向量元素的指针

std::vector<Element> items { e0, e1, e2, e3, e4, e5, e6, e7 };
auto tuple = std::make_tuple(&items[0], &items[2], &items[6]);

还是一个带有指向3个向量元素指针的原始数组？（可能带有附加的数组大小函数参数）

std:：向量项{e0、e1、e2、e3、e4、e5、e6、e7}；
元素子项[3]{&items[0]，&items[2]，&items[6]}；

有很多可能性，但我会选择一个新的带有副本的向量，除非这是不必要的昂贵，在这种情况下，指向原始向量的指针将是第二选择。创建向量不太可能是性能问题。
您可以插入一个转发函数来为您选择索引：

template <size_t... Is, typename F, typename C>
auto fwd_indices(F func, C& cont)
-> decltype(func(cont[Is]...))
{
    return func(cont[Is]...);
}

模板
自动fwd_索引（F func，C&cont）
->decltype（func（cont[Is]…））
{
返回函数（cont[Is]…）；
}

这是一个零拷贝、零额外对象解决方案。您可以这样使用该功能：

std::vector<int> v = { .. };
fwd_indices<0, 2, 6>(some_func, v); // calls some_func(v[0], v[2], v[6]);
                                    // which hopefully takes them by-ref

std:：vector v={..}；
fwd_指数（某些函数，v）；//调用一些函数（v[0]，v[2]，v[6]）；
//这很有可能会让他们成为裁判

如果您只知道在运行时需要转发哪些索引，那么这是一个错误。但如果你在编译时就知道了，这对我来说似乎很清楚
 您可以传递迭代器向量：

#include <vector>
#include <iostream>

using itr_type = std::vector<double>::const_iterator;

void doSomethingWithItrVec(std::vector<itr_type> itr_vec) {
  for (auto itr : itr_vec)
    std::cout << *itr << "\n";
}

int main() {
    std::vector<double> v = {0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1.0};
    auto begin = v.cbegin();
    doSomethingWithItrVec({begin, begin + 2, begin + 6});
}

#包括
#包括
使用itr_type=std:：vector:：const_迭代器；
void doSomethingWithItrVec（标准：：向量itr_vec）{
用于（自动itr:itr\U vec）
std:：cout作为单个参数，我看不到解决方案。但是，您可以尝试一个可变函数。在这里使用
std:：reference_wrapper
而不是指针有什么好处吗？@user2079303的好处是意图更明确。在
f
的实现方面没有太大区别；您可能需要使用
get（）
-但您可能不会，在这种情况下，它会保存在间接寻址操作符上。
#include <vector>
#include <iostream>

using itr_type = std::vector<double>::const_iterator;

void doSomethingWithItrVec(std::vector<itr_type> itr_vec) {
  for (auto itr : itr_vec)
    std::cout << *itr << "\n";
}

int main() {
    std::vector<double> v = {0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1.0};
    auto begin = v.cbegin();
    doSomethingWithItrVec({begin, begin + 2, begin + 6});
}