c++ 转换和 lambda - 替换 for 循环

Question

我想用 std::transform 替换 for 循环。由于我对算法和 lambda 函数的经验很少，我想知道这是否是正确的方法

原始代码

for (size_t i=0; i < dataPhase.size(); ++i)
{
    dataPhase[i] = fmod(dataPhase[i], pi*1.00001);
}

std::transform 与 lambda

std::transform(dataPhase.begin(), dataPhase.end(), dataPhase.begin(), 
               [](double v){return fmod(v, pi*1.00001); }
);

我需要在这里抓拍吗？

在这种使用索引的情况下，我可以做些什么来替换 for 循环，如下代码所示：

const int halfsize = int(length/2);
for (size_t i=0; i < length; ++i)
{
    axis[i] = int(i) - halfsize;
}

编辑： 我想扩展问题（如果允许）。

在这种情况下是否可以用不同的东西替换 for 循环

for(std::vector<complex<double> >::size_type i = 0; i != data.size(); i++) {
    dataAmplitude[i] = abs(data[i]);
    dataPhase[i]     = arg(data[i]);
}

这里没有修改原始向量，而是将其值用于两个不同的向量。

Answer 1

第 1 部分）

这里不需要捕获，因为您只在 lambda 代码中使用参数 (v) 和全局变量 (pi)。

仅当 lambda 必须从当前范围访问变量（即在您的函数中声明）时才需要捕获。您可以按引用 (&) 或按值 (=) 捕获。

这是一个示例，其中需要“通过引用捕获”，因为“结果”是从 lambda 中修改的（但它也捕获了“搜索值”）：

size_t count(const std::vector<char>& values, const char searchValue)
{
 size_t result = 0;
 std::for_each(values.begin(), values.end(), [&](const char& v) {
  if (v == searchValue)
   ++result;
 });
 return result;
}

（在现实世界中请使用std::count_if() 甚至std::count()）

编译器为每个捕获的 lamda 创建一个未命名的仿函数（请参阅this question）。函数的构造函数接受参数并将其存储为成员变量。因此，“按值捕获”始终使用元素在定义 lambda 时的值。

下面是编译器可以为我们之前创建的 lambda 生成的代码示例：

class UnnamedLambda
{
public:
 UnnamedLambda(size_t& result_, const char& searchValue_)
  : result(result_), searchValue (searchValue_)
 {}

 void operator()(const char& v)
 {
  // here is the code from the lambda expression
  if (v == searchValue)
   ++result;
 }

private:
 size_t& result;
 const char& searchValue;
};

我们的函数可以重写为：

size_t count(const std::vector<char>& values, const char searchValue)
{
 size_t result = 0;
 UnnamedLambda unnamedLambda(result, searchValue);
 for(auto it = values.begin(); it != values.end(); ++it)
  unnamedLambda(*it);
 return result;
}

第 2 部分）

如果您需要索引，请继续使用 for 循环。

std::transform 允许处理单个元素，因此不提供索引。还有一些其他算法，例如 std::accumulate 可以处理中间结果，但我不知道任何提供索引的算法。

Answer 2

您的所有示例都可以转换为 std::transform 的使用，并使用一些额外的对象来做腿部工作（我在这里使用 boost，因为它是大多数所需类的现有技术）

// 1
for (size_t i=0; i < dataPhase.size(); ++i)
{
    dataPhase[i] = fmod(dataPhase[i], pi*1.00001);
}

// 2
const int halfsize = int(length/2);
for (size_t i=0; i < length; ++i)
{
    axis[i] = int(i) - halfsize;
}

// 3
for(std::vector<complex<double> >::size_type i = 0; i != data.size(); i++) {
    dataAmplitude[i] = abs(data[i]);
    dataPhase[i]     = arg(data[i]);
}

正如你正确注意到的，1 变成了

std::transform(dataPhase.begin(), dataPhase.end(), dataPhase.begin(), 
    [](double v){return fmod(v, pi*1.00001); } );

2需要一个数字序列，所以我用boost::integer_range

const int halfsize = int(length/2);
 // provides indexes 0, 1, ... , length - 1
boost::integer_range<int> interval = boost::irange(0, length);
std::transform(interval.begin(), interval.end(), axis.begin(), 
    [halfsize](int i) {return i - halfsize;}); 

3 涉及一对（2 元组）输出，所以我使用boost::zip_iterator 作为目标

std::transform(data.begin(), data.end(), 
    // turns a pair of iterators into an iterator of pairs
    boost::make_zip_iterator(dataAmplitude.begin(), dataPhase.begin()), 
    [](complex<double> d) { return boost::make_tuple(abs(d), arg(d)); });

Answer 3

这里有一些lambda captures的例子：

[] 不捕获任何内容

[&] 通过引用捕获任何被引用的变量

[=] 通过复制来捕获任何引用的变量

[=, &foo] 通过复制来捕获任何引用的变量，但是 通过引用捕获变量 foo

[bar] 通过复制捕获bar；不要复制任何东西

[this] 捕获封闭类的this指针

因此，如果您的示例中的 pi 是 local 变量（不是宏或全局变量），您不能让 [] 而是使用 [pi] 来捕获复制（这对于 double 来说是正常的）：

std::transform(dataPhase.begin(), dataPhase.end(), dataPhase.begin(), 
           [pi](double v){return fmod(v, pi*1.00001); }
);

对于您的第二个示例，没有内置的 std::transform 提供索引。我认为更好的解决方案是保留你的 for 循环。

如果你真的想使用 lambda（作为练习），你可以使用：

const int halfsize = int(length/2);

auto lambda=[&axis,halfsize](const int i){axis[i] = i - halfsize;};

for (size_t i=0; i < length; ++i)
{
    lambda(i);
}

或

const int halfsize = int(length/2);

auto lambda=[halfsize](const int i){return i - halfsize;};  

for (size_t i=0; i < length; ++i)
{
   axis[i] = lambda(i);
}

这仅取决于您希望如何设计代码。

备注 1： 似乎您希望避免“基本”for 循环，但它们并不是必要的邪恶，特别是如果您想使用 OpenMP 获得一些性能（simd 或多线程） .比如

 #pragma omp simd
 for(auto& v_i :v) {   // or worst std::transform
    v_i = fmod(v_i, pi*1.00001);
 }

不支持且不会编译。

然而

 #pragma omp simd
 for (size_t i=0; i < dataPhase.size(); ++i)
 {
     dataPhase[i] = fmod(dataPhase[i], pi*1.00001);
 }    

可以使用 g++ -fopenmp ... 如果可以使用 simd 则具有潜在的性能增益。关于多线程，可以说即将支持 STL 算法的并行执行，但这仅适用于 C++17。

备注 2： 不是在 C++ 中，而是在 D language 中，您有一个 foreach 指令，可以让您选择性地包含索引：

foreach (e; [4, 5, 6]) { writeln(e); }
// 4 5 6

但是

foreach (i, e; [4, 5, 6]) { writeln(i, ":", e); }
// 0:4 1:5 2:6