Question

我正在编写奥林匹克运动会的各种节目，并试图提高时间效率。我正在寻找最快的输入方式，使用没有任何外部库的gcc编译器。

我之前使用过cin和cout，但发现scanf和printf要快得多。还有更快的方法吗？我不太关心空间复杂性，我宁愿选择更好的时间。

Answer 1

流总是比C-API函数慢，这是一个非常常见的误解，因为默认情况下，它们与C层同步。所以，是的，这是一个功能，而不是一个错误。

在不牺牲类型安全性（以及可读性，取决于您的口味）的情况下，您可以通过使用以下方式获得流的性能：

std::ios_base::sync_with_stdio (false);

一个小指标：

#include <cstdio>
#include <iostream>

template <typename Test> 
void test (Test t)
{
    const clock_t begin = clock();
    t();
    const clock_t end = clock();
    std::cout << (end-begin)/double(CLOCKS_PER_SEC) << " sec\n";
}

void std_io() {
    std::string line;
    unsigned dependency_var = 0;

    while (!feof (stdin)) {
        int c;
        line.clear();
        while (EOF != (c = fgetc(stdin)) && c!='\n')
            line.push_back (c);
        dependency_var += line.size();
    }

    std::cout << dependency_var << '\n';
}

void synced() {
    std::ios_base::sync_with_stdio (true);
    std::string line;
    unsigned dependency_var = 0;
    while (getline (std::cin, line)) {
        dependency_var += line.size();
    }
    std::cout << dependency_var << '\n';
}

void unsynced() {
    std::ios_base::sync_with_stdio (false);
    std::string line;
    unsigned dependency_var = 0;
    while (getline (std::cin, line)) {
        dependency_var += line.size();
    }
    std::cout << dependency_var << '\n';
}

void usage() { std::cout << "one of (synced|unsynced|stdio), pls\n"; }

int main (int argc, char *argv[]) {
    if (argc < 2) { usage(); return 1; }

    if (std::string(argv[1]) == "synced") test (synced);
    else if (std::string(argv[1]) == "unsynced") test (unsynced);
    else if (std::string(argv[1]) == "stdio") test (std_io);
    else { usage(); return 1; }

    return 0;
}

使用g ++ -O3和一个大文本文件：

cat testfile | ./a.out stdio
...
0.34 sec

cat testfile | ./a.out synced
...
1.31 sec

cat testfile | ./a.out unsynced
...
0.08 sec

这适用于您的情况取决于。修改此玩具基准，添加更多测试，并比较例如std::cin >> a >> b >> c与scanf ("%d %d %d", &a, &b, &c);之类的内容。我保证，通过优化（即不处于调试模式），性能差异将是微妙的。

如果这不能满足您的需求，您可以尝试其他方法，例如：首先读取整个文件（可能会或可能不会带来更多性能）或内存映射（这是一个非便携式解决方案，但大型桌面有它们）。

更新

格式化输入：scanf与流

#include <cstdio>
#include <iostream>

template <typename Test> 
void test (Test t)
{
    const clock_t begin = clock();
    t();
    const clock_t end = clock();
    std::cout << (end-begin)/double(CLOCKS_PER_SEC) << " sec\n";
}

void scanf_() {
    char x,y,c;
    unsigned dependency_var = 0;

    while (!feof (stdin)) {
        scanf ("%c%c%c", &x, &y, &c);
        dependency_var += x + y + c;
    }

    std::cout << dependency_var << '\n';
}

void unsynced() {
    std::ios_base::sync_with_stdio (false);
    char x,y,c;
    unsigned dependency_var = 0;
    while (std::cin) {
        std::cin >> x >> y >> c;
        dependency_var += x + y + c; 
    }
    std::cout << dependency_var << '\n';
}

void usage() { std::cout << "one of (scanf|unsynced), pls\n"; }

int main (int argc, char *argv[]) {
    if (argc < 2) { usage(); return 1; }

    if (std::string(argv[1]) == "scanf") test (scanf_);
    else if (std::string(argv[1]) == "unsynced") test (unsynced);
    else { usage(); return 1; }

    return 0;
}

结果：

scanf: 0.63 sec
unsynced stream: 0.41

Answer 2

通常，缓冲输入将是最快的。您必须刷新输入缓冲区的频率越低，输入就越快。有关完整且内容丰富的讨论，请参阅this question。简而言之，具有大缓冲区大小的read（）速度最快，因为它几乎直接位于操作系统中相应的系统调用之上。

Answer 3

可能scanf比使用流更快一些。虽然流提供了很多类型安全性，并且不必在运行时解析格式字符串，但它通常具有不需要过多内存分配的优点（这取决于您的编译器和运行时）。也就是说，除非性能是你唯一的最终目标，并且你处于关键路径，否则你应该更喜欢更安全（更慢）的方法。

Herb Sutter在这里写了一篇非常好吃的文章

http://www.gotw.ca/publications/mill19.htm

谁详细介绍了sscanf和lexical_cast等字符串格式化程序的性能，以及使它们运行缓慢或快速的事情。这有点类似，可能会影响C风格IO和C ++风格之间的性能。与格式化程序的主要区别往往是类型安全性和内存分配数。

这是C ++中最快的输入方法

3 个答案:

更新

格式化输入：scanf与流