头尾打印是否比检查结束或开始更有效？

Question

所以我有一个清单。我想打印该列表中用空格分隔的所有元素。

我首先想到的是做，

for (auto& ele : somelist)
{
  cout << ele << ' ';
}

或者，

for (auto& ele : somelist)
{
  cout << ' ' << ele;
}

问题在于引入了额外的空间。

因此，处理多余空间的一种方法是使用条件。

for (int idx{}; idx < somelist.size(); ++idx)
{
  if (idx == 0)
    cout << somelist[idx];

  else
    cout << ' ' << somelist[idx];
}

或者，

for (int idx{}; idx < somelist.size(); ++idx)
{
  if (idx == somelist.size() - 1)
    cout << somelist[idx];

  else
    cout << somelist[idx] << ' ';
}

但是有一个条件只有一次才会成立，这让我很困扰。我想出了自己的方法来打印一个列表，使用 lambdas 来管理是否插入了额外的空间，而不检查每次迭代。

#include <iostream>
#include <functional>

int main(int argc, char *argv[])
{
  auto printHead = [] (int num)
    {
      std::cout << num;
    };

  auto printTail = [] (int num)
    {
      std::cout << ' ' << num;
    };

  // Need explicit type for lambda if its going to be captured
  std::function<void(int)> print = [&printHead, &printTail, &print] (int num)
    {
      printHead(num);
      print = printTail;
    };

  for (auto& element : {1,2,3,4,5,6,6,7,8,9,6})
  {
    print(element);
  }

  return 0;
}

假设这个解决方案在性能方面比原始条件版本更有效，是否合理？

Answer 1

您可以使用 "Loop and a Half" 构造（我不确定我是否将指令计数与 @Cornstalks 相同，但 gcc -S -o - 提供 153 行汇编）：

#include <iostream>
#include <vector>

int main()
{
    auto somelist = std::vector<int>{1,2,3,4,5,6,6,7,8,9,6};

    auto first = begin(somelist), last = end(somelist);
    if (first != last) {                // initial check
        while (true) {
            std::cout << *first++;     
            if (first == last) break;   // check in the middle
            std::cout << ", ";
        }
    }
}

Live Example 打印

1、2、3、4、5、6、6、7、8、9、6

即在最后一个元素的末尾没有分隔符（我使用“，”作为分隔符，因为它比空格更容易发现，当然可以根据您的意愿进行调整）。

“中间检查”是它与 range-for、while 或 do-while 循环不同的原因。它还将一个 lambda 拆分为两个 std::for_each，这表明一个非常通用的版本将 std::for_each 推广到一个循环，该循环采用两个 lambda，一个在检查之前，一个在检查之后：

template<class It, class UnaryOp1, class UnaryOp2>
void loop_and_a_half(It first, It last, UnaryOp1 op1, UnaryOp2 op2)
{
    if (first == last) return;
    while (true) {
        op1(*first++);
        if (first == last) break;
        op2(*first);
    }    
}

可以这样调用（使用 C++14 通用 lambda）：

loop_and_a_half(
    begin(somelist), end(somelist),
    [](auto e) { std::cout << e; },
    [](auto) { std::cout << ", "; }
);

Live Example 打印相同的输出。

Answer 2

将条件放在循环之外怎么样？

if (!somelist.empty()) std::cout << somelist[0];
for (int i = 1; i < somelist.size(); ++i)
{
    std::cout << ' ' << somelist[i];
}

编辑：我没有回答实际问题。对比一下：

方法 1（~243 条指令）：

std::vector<int> somelist = {1,2,3,4,5,6,6,7,8,9,6};
for (int idx{}; idx < somelist.size(); ++idx)
{
    if (idx == 0)
        std::cout << somelist[idx];

    else
        std::cout << ' ' << somelist[idx];
}

方法 2（~555 条指令）：

auto printHead = [] (int num)
    {
        std::cout << num;
    };

auto printTail = [] (int num)
    {
        std::cout << ' ' << num;
    };

// Need explicit type for lambda if its going to be captured
std::function<void(int)> print = [&printHead, &printTail, &print] (int num)
    {
        printHead(num);
        print = printTail;
    };

std::vector<int> somelist = {1,2,3,4,5,6,6,7,8,9,6};
for (auto& element : somelist)
{
    print(element);
}

方法 3（~240 条指令）：

std::vector<int> somelist = {1,2,3,4,5,6,6,7,8,9,6};

if (!somelist.empty()) std::cout << somelist[0];
for (int i = 1; i < somelist.size(); ++i)
{
    std::cout << ' ' << somelist[i];
}

这些都是在 OS X 上使用 clang++ 3.3 编译的，带有-Ofast -flto。虽然处理器是复杂的野兽，而且很难说哪个版本最快（在所有 CPU 中），但我认为方法 #3 可能是最快的（基于指令数），其次是关闭方法 #1，然后是方法#2。看起来您提出的方法阻止了很多编译器优化。

Answer 3

不涉及std::function 的更简单的解决方案怎么样？

char space = '\0';
for (auto& ele : somelist)
{
  cout << space << ele;
  space = ' ';
}

或者你可以使用迭代器

auto first = somelist.cbegin();
auto last = somelist.cend();

if(first != last) {
  cout << *first++;
}
for(; first != last; ++first) {
  cout << ' ' << *first;
}

---

std::function 使用类型擦除，很可能通过虚函数，将调用分派给目标函数；这将涉及一些开销。要确定它是否比其他示例更快/更慢，您只需对其进行测量。

Answer 4

为什么不对列表和列表元素都实现'

• 列表的“
• 每个元素的 '

这会将您的原始代码简化为：

cout << somelist;