当我对 fprintf() 进行测试时, fputs() , 和 ofstream operator (<<) ，我意识到 C 函数(两者)提供了更好的运行时性能，但是当输入字符串变大时，两个 C 函数的运行速度都比 C++ 的运算符慢。

我想知道 C++ 在小字符串上表现不佳的原因，以及它在大字符串上优于 C 的原因。

欣赏它。

注意:不幸的是，我无法共享大小超过 1000 个字符的字符串。

测试结果

- String Size -> 20 chars, C++(<<): 0,80 C(fprintf): 0,50 C(fputs):
   0,20
- String Size -> 50 chars, C++(<<): 1,06 C(fprintf): 0,80 C(fputs):
   0,35
- String Size -> 1000 chars, C++(<<): 6,39 C(fprintf): 8,35 C(fputs):
   5,01

-  String Size -> 2000 chars, C++(<<): 12,33 C(fprintf): 16,84 C(fputs):
   9,06

-   String Size -> 50000 chars, C++(<<): 0,20 C(fprintf): 0,39 C(fputs):
   0,27 (1000 runs instead of 1 million runs)

-   String Size -> 100000 chars, C++(<<): 0,40 C(fprintf): 0,45 C(fputs):
   0,74 (1000 runs instead of 1 million runs)

这是代码

#include <iostream>
#include <fstream>
#include <string.h>
#include "Stopwatch.h"

using namespace std;

void testNewline(string test_str,int run){
    StopWatch timer;
    ofstream outdata("writeToFile-CPP-newline.txt");
    timer.start();
    for (int i = 0 ; i < run ; i++){
        outdata << i << ":" << test_str << "\n";
    }
    timer.stop();
    outdata.close();
    cout << "C++ Time spent:  - " << timer.seconds() << endl;
}

int main() {
    int run = 1000000;
    string test_str(str100);
    size_t len = test_str.length();
    cout << "Write File - " << run << " Runs\n";
    cout << "Length is " << len << " chars\n";

    testNewline(test_str,run);

    return 0;
}

秒表.h - Cpp

#include <time.h>
#ifndef STOPWATCH_H_
#define STOPWATCH_H_

#define str20 "a very long literal "
#define str50 "a very long literal string a very very long string"
#define str100 "a very long literal string a very very long stringa very long literal string a very very long string"
#define str1000 ...
#define str2000 ...
#define str50000 ...

class StopWatch{
private:
    clock_t start_;
    clock_t end_;
    bool isRunning_;
public:
    void start(){
        start_ = clock();
        end_ = 0;
        isRunning_ = true;
    }

    void stop(){
        if(isRunning_){
            end_ = clock();
            isRunning_ = false;
        }
    }

    double seconds() const
    {
        return double (end_ - start_) / CLOCKS_PER_SEC;
    }

    StopWatch(): start_(), end_(), isRunning_() {}
};    
#endif /* STOPWATCH_H_ */

WriteFile.c

#include <stdio.h>
#include <stdlib.h>
#include "Stopwatch.h"

int main(void) {

    const int run = 1000000;
    int i;
    size_t len = strlen(str100);
    char *test_str = (char *) malloc(sizeof(char)*(len+1));
    strcpy(test_str,str100);

    FILE *file = fopen("writeToFile-C.txt","w");
    clock_t start_ = start();
    for (i = 0; i < run ; i++){
        fputs(test_str,file);
    }
    clock_t end_ = stop();
    fclose(file);

    printf("Write File - %d Runs\nString Length is %d chars\nC (fputs) Time spent: %.2f seconds\n",run,len,seconds(start_,end_));

    FILE *file2 = fopen("writeToFile-C-2.txt","w");
    clock_t start2_ = start();
    for (i = 0; i < run ; i++){
        fprintf(file2,"%d:%s\n",i,test_str);
    }
    clock_t end2_ = stop();
    fclose(file2);

    printf("Write File - %d Runs\nString Length is %d chars\nC (fprintf) Time spent: %.2f seconds\n",run,len,seconds(start2_,end2_));

    return EXIT_SUCCESS;
}

StopWatch.h - C

#include <time.h>
#include <string.h>
#ifndef STOPWATCH_H_
#define STOPWATCH_H_

#define str20 "a very long literal "
#define str50 "a very long literal string a very very long string"
#define str100 "a very long literal string a very very long stringa very long literal string a very very long string"
#define str1000 ...
#define str2000 ...
#define str50000 ...  

clock_t start(){
    return clock();
}

clock_t stop(){
    return clock();
}

double seconds(clock_t start, clock_t end)
{
    return (double) (end - start) / CLOCKS_PER_SEC;
}

#endif /* STOPWATCH_H_ */

我使用了 MinGW 编译器。

为 C++ 编译代码:g++ -O3 -Wall -c
为 C 编译代码:gcc -O3 -Wall -c

编辑:我不担心小字符串的微不足道的差异，但这是学术上的好奇心。

最佳答案

这是一个有趣的问题。重申一下，问题是:为什么 fputs和 fprintf短字符串更快，而 <<至 cout越长的字符串越快？

我怀疑，正如一些评论中所建议的那样，<<至 cout更快，因为 C++ 字符串预先明确地携带它们的大小。另一方面，C 风格的字符串需要扫描以找到终止 '\0'。 ，这是一项额外费用。

但是，<<的开销和 cout更大，所以对于较短的字符串来说，它的优势是看不到的。

我编写了您的程序的另一个版本(附在下面)并在各种字符串大小和试验次数上进行了尝试，这些结果在我的机器上。我还扔了 stdio 函数 fwrite混入其中。

string length   trials       cout     fprintf  fputs    fwrite
10              100000000    9        8        8        7
100             100000000    10       9        8        8
1000            100000000    14       17       18       12
10000           10000000     6        10       10       6
100000          1000000      4        10       9        4
1000000         1000000     11        72       71       10
10000000        100000       7        95       94       8

大概重要的区别是 fprintf和 fputs必须打印字符 同时检查每个字符是否为 \0 。 cout和 << ，另一方面，像fwrite , 预先知道字符数，因此可以盲目地准确地写出那么多。

cout 的强大功能和灵 active 和 <<以(小)价格出现，但它似乎是一次性成本，每次“调用”而不是每次写入的字符。

然后 fwrite ，它也预先知道计数，与 cout 一样好， 或更好。看起来像 cout不知何故在最后一次最大的审判中勉强获胜，这有点令人惊讶。可能只是因为每次调用 fwrite必须传递四个参数，并且 fwrite必须对 nels 进行额外的乘法运算× elsize .

但综上所述，任何时候我们检查性能时，请务必记住，如果您必须执行数百万次仔细控制的试验才能检测到微小的差异，那么差异可能并不重要在实践中很重要。使用对您来说最自然的 i/o 风格、您要解决的问题以及您使用的语言。除非您正在编写一个 I/O 密集型的高性能程序，否则您使用哪个 I/O 调用可能无关紧要。

特别是，我作弊了:我在运行所有试验时都将标准输出重定向到/dev/null，以最大限度地减少 i/o 时间，并最大限度地提高四种被测方法之间的实际计算差异。如果输出是“真实的”——文件、管道或网络流——我怀疑它会主导性能，我将不得不进行更多的试验来显示这些方法之间的任何差异。

最后，这是我使用的程序:

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
#include <string>
#include <iostream>

int main(int argc, char *argv[])
{
    int n = atoi(argv[1]);
    int m = atoi(argv[2]);
    char *p = (char *)malloc(n);
    memset(p, 'x', n-2);
    p[n-2] = '\n';
    p[n-1] = '\0';
    std::string s = p;
    int i;
    time_t t1, t2, t3, t4, t5;

    t1 = time(NULL);
    for(i = 0; i < m; i++)
        std::cout << s;
    t2 = time(NULL);
    for(i = 0; i < m; i++)
        fprintf(stdout, "%s", p);
    t3 = time(NULL);
    for(i = 0; i < m; i++)
        fputs(p, stdout);
    t4 = time(NULL);
    for(i = 0; i < m; i++)
        fwrite(p, 1, n, stdout);
    t5 = time(NULL);

    fprintf(stderr, "cout %ld ",    t2-t1);
    fprintf(stderr, "fprintf %ld ", t3-t2);
    fprintf(stderr, "fputs %ld ",   t4-t3);
    fprintf(stderr, "fwrite %ld\n", t5-t4);
}

关于c++ - fprintf/fputs 与大字符串的 cout 性能，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/51149880/