当我在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;
}
Stopwatch.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
编辑：我并不担心小字符串的微小差异，但这是学术上的好奇心。
答案 0 :(得分：5)
这是一个有趣的问题。重述的问题是：为什么短字符串的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和<<的功能和灵活性要付出（小的）代价，但这似乎是一次性的成本，即每个“通话”而不是每个书写的字符。
然后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);
}