C++ C++；使用迭代器在iterable上映射函数

我有一个函数，它接受大的

std:：vectors

（通过

const&

）并返回大的向量（通过值）。在代码的一部分中，我需要执行以下操作：

std::list<std::vector<double> > all_vectors;
// all_vectors is filled with values somewhere in here
for (const std::vector & v : all_values)
{
   std::vector<double> res = f(v);
   // do something with res
}

std::list<std::vector<double> > all_vectors;
// all_vectors is filled with values somewhere in here
for (const std::vector & v : all_values)
{
   std::vector<double> res = f(v);
   // do something different with res
}

std:：列出所有_向量；
//所有的_向量都在这里的某个地方填充了值
用于（常数std:：vector&v:所有_值）
{
标准：向量res=f（v）；
//用res做点什么
}

在代码的另一部分，我需要做：

std::list<std::vector<double> > all_vectors;
// all_vectors is filled with values somewhere in here
for (const std::vector & v : all_values)
{
   std::vector<double> res = f(v);
   // do something with res
}

std::list<std::vector<double> > all_vectors;
// all_vectors is filled with values somewhere in here
for (const std::vector & v : all_values)
{
   std::vector<double> res = f(v);
   // do something different with res
}

std:：列出所有_向量；
//所有的_向量都在这里的某个地方填充了值
用于（常数std:：vector&v:所有_值）
{
标准：向量res=f（v）；
//用res做些不同的事情
}

最简单的选项（内存占用）： 通过简单地将

f

映射到

所有的

值上，然后检查结果并执行

//使用res做一些事情

或

//使用res做一些不同的事情（针对每种情况），重用代码是很简单的。这样做的缺点是，我（不必要地）需要存储一长串大型
std:：vector
s。一方面，我尽可能确信它不会比我使用更多的内存；但即便如此，不必要地存储大量数据似乎也是一种不好的做法

选项1（根据请求使用迭代器生成结果）：
一个选项是创建一些迭代器映射函数，其行为类似于map，但根据需要生成结果。我认为，使用Python的
产量
，这是非常可行的

选项2（使用面向对象设计）：
另一个选项是使用
ABC
继承并重写函数
g
：在一个派生类中，
g
将执行
//使用res
做一些事情，而在另一个派生类中，它将执行
//使用res做一些不同的事情

选项3+（？）：

我真的很想听听你的建议，告诉你如何处理C++中的类似问题。提前感谢。
为什么需要按值返回向量？如果可以通过引用返回并使用
vector:：const_迭代器
，则可以确保不会修改原始向量

如果您确实需要一个副本，那么在这两种情况下您很可能需要一个不同的副本，因此您的选项0将不起作用

如果您正在编译来自列表中向量的值的混搭集合，迭代器选项对我来说最合适——每次调用
操作符+
，您都可以动态计算下一个元素。
f（v）将过滤向量并返回v的子集？否，
f（v）
计算
v
中的密集高斯平滑值。我需要按值返回，因为结果是从
v
创建的。但我同意，如果它是迭代器，我可以分配一个
常量&
返回值，然后继续返回。但除了分配/解除分配成本外，运行时大致相同（返回值中的每个元素都需要计算，一次只存在一个返回值副本）。