我编写了一个程序来计算 8 个字符的字符串“sharjeel”的排列。

#include <iostream>
#include <time.h>

char string[] = "sharjeel";
int len = 8;
int count = 0;

void swap(char& a, char& b){
    char t = a;
    a = b;
    b = t;
}
void permute(int pos) {
    if(pos==len-1){
        std::cout << ++count << "\t" << string << std::endl;
        return;
    }
    else {
        for (int i = pos; i < len;i++)
        {
            swap(string[i], string[pos]);
            permute(pos + 1);
            swap(string[i], string[pos]);
        }
    }
}

int main(){
    clock_t start = clock();
    permute(0);
    std::cout << "Permutations: " << count << std::endl;
    std::cout << "Time taken: " << (double)(clock() - start) / (double)CLOCKS_PER_SEC << std::endl;
    return 1;
}

如果我打印每个排列，则大约需要 9.8 秒才能完成执行。

40314   lshaerej
40315   lshareej
40316   lshareje
40317   lshareej
40318   lshareje
40319   lsharjee
40320   lsharjee
Permutations: 40320
Time taken: 9.815

现在如果我替换行:

std::cout << ++count << "\t" << string << std::endl;

用这个:

++count;

然后重新编译，输出为:

Permutations: 40320
Time taken: 0.001

再次运行:

Permutations: 40320
Time taken: 0.002

使用带 -O3 的 g++ 编译

为什么 std::cout 这么耗时？有没有更快的打印方式？

编辑:制作了程序的 C# 版本

/*
 * Permutations
 * in c#
 * much faster than the c++ version 
 */

using System;
using System.Diagnostics;

namespace Permutation_C
{
    class MainClass
    {
        private static uint len;
        private static char[] input;
        private static int count = 0;

        public static void Main (string[] args)
        {
            Console.Write ("Enter a string to permute: ");
            input = Console.ReadLine ().ToCharArray();
            len = Convert.ToUInt32(input.Length);
            Stopwatch clock = Stopwatch.StartNew();
            permute (0u);
            Console.WriteLine("Time Taken: {0} seconds", clock.ElapsedMilliseconds/1000.0);
        }

        static void permute(uint pos)
        {

            if (pos == len - 1u) {
                Console.WriteLine ("{0}.\t{1}",++count, new string(input));
                return;
            } else {
                for (uint i = pos; i < len; i++) {
                    swap (Convert.ToInt32(i),Convert.ToInt32(pos));
                    permute (pos + 1);
                    swap (Convert.ToInt32(i),Convert.ToInt32(pos));
                }
            }

        }
        static void swap(int a, int b) {
            char t = input[a];
            input[a] = input[b];
            input[b] = t;
        }
    }
}

输出:

40313.  lshaerje
40314.  lshaerej
40315.  lshareej
40316.  lshareje
40317.  lshareej
40318.  lshareje
40319.  lsharjee
40320.  lsharjee
Time Taken: 4.628 seconds
Press any key to continue . . .

从这里开始，与 std::cout 的结果相比，Console.WriteLine() 的速度似乎几乎快了一倍。什么似乎在减慢 std::cout 的速度？

最佳答案

std::cout最终导致操作系统被调用。

如果您希望某些东西能够快速计算，您必须确保没有外部实体参与计算，尤其是在编写时考虑的是多功能性而非性能的实体，例如操作系统。

想让它跑得更快？您有几个选择:

1. 替换<< std::endl;与 << '\n' .这将避免在每一行上将 C++ 运行时的内部缓冲区刷新到操作系统。它应该会带来巨大的性能提升。

2. 使用 std::ios::sync_with_stdio(false);正如用户 Galik Mar 在评论中建议的那样。

3. 在缓冲区中收集尽可能多的传出文本，并通过一次调用一次性输出整个缓冲区。

4. 将输出写入文件而不是控制台，然后通过单独的应用程序(例如 Notepad++)显示该文件，它可以跟踪更改并一直滚动到底部。

至于为什么这么“耗时”，(换句话说，慢，)那是因为std::cout的主要目的。 (最终是操作系统的标准输出流)是多功能性，而不是性能。想一想:std::cout是将调用操作系统的 C++ 库函数；操作系统会判断写入的文件不是真正的文件，而是控制台，因此会将数据发送到控制台子系统；控制台子系统将接收数据并开始调用图形子系统以在控制台窗口中呈现文本；图形子系统将在光栅显示器上绘制字体字形，在渲染数据时，控制台窗口将滚动，这涉及复制大量视频 RAM。这是一项非常多的工作，即使显卡在硬件中承担了其中的一部分。

至于 C# 版本，我不确定到底发生了什么，但可能发生的事情是完全不同的:在 C# 中你没有调用 Console.Out.Flush() ，所以你的输出被缓存并且你不会遭受 C++ 的 std::cout << std::endl 引起的开销这导致每一行都被刷新到操作系统。 但是，当缓冲区变满时，C# 必须将其刷新到操作系统，然后它不仅会受到表示的开销的影响由操作系统，但也由虚拟机工作方式中固有的强大的托管到 native 和 native 到托管的转换。

关于c++ - 为什么 std::cout 如此耗时？，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/43051948/