对于scanf和cin的输入输出速度的验证

最新推荐文章于 2025-02-25 07:00:00 发布
最新推荐文章于 2025-02-25 07:00:00 发布
阅读量76 收藏
点赞数
CC 4.0 BY-SA版权
原文链接：http://www.cnblogs.com/hushuangpu/p/6661464.html
本文通过一系列实验对比了不同文件读取方法在多种环境下的性能表现，包括scanf、cin、fread、read及mmap等，并分析了各种方法的优劣。

本文为https://www.byvoid.com/zhs/blog/fast-readfile的验证性文章

---------------------------------------------------------------------------

首先生成一千万个随机数

 1 #include<cstdio>                       
 2 #include<ctime>                        
 3 #include<cstdlib>                      
 4 int main ()                            
 5 {                                      
 6         freopen("data.txt","w",stdout);
 7         srand(time(0));                
 8         for(int i=0;i<10000000;i++)     
 9                 printf("%d ",rand());  
10         return 0;                      
11 }

我用重定向把数据导出到"data.txt"了。

然后，用scanf来读取数据，并计时

 1 #include<cstdio>                                               
 2 #include<ctime>
 3 int a[10000000];                                                
 4 int main ()                                                    
 5 {                                                              
 6         int start = clock();                                 
 7         freopen("data.txt","r",stdin);                         
 8         for(int i=0;i<10000000;i++)                             
 9                 scanf("%d",&a[i]);                                
10         printf("%.3lf\n",double(clock()-start)/CLOCKS_PER_SEC);
11 }

执行之后，使用时间为1.18s，相比于原文的2.01秒，缩短了一截，然后测试一下使用cin输入的情况，代码如下:

 1 #include<cstdio>
 2 #include<ctime>
 3 #include<iostream>
 4 int a[10000000];
 5 int main ()
 6 {
 7         int start = clock();
 8         freopen("data.txt","r",stdin);
 9         for(int i=0;i<10000000;i++)
10                 std::cin>>a[i];
11         printf("%.3lf\n",double(clock()-start)/CLOCKS_PER_SEC);
12 }

cin的使用时间为4.67s，比scanf更长，但是相比于原文的6.38s还是短得多。
然后取消cin与stdin之间的同步之后，代码如下:

 1 #include<cstdio>
 2 #include<ctime>
 3 #include<iostream>
 4 int a[10000000];
 5 int main ()
 6 {
 7         int start = clock();
 8         std::ios::sync_with_stdio(false);
 9         freopen("data.txt","r",stdin);
10         for(int i=0;i<1000000;i++)
11                 std::cin>>a[i];
12         printf("%.3lf\n",double(clock()-start)/CLOCKS_PER_SEC);
13 }

时间大幅缩短，为1.24s，与scanf很接近了。
然后按原文测试读入整个文件,代码如下:

 1 #include<iostream>                                              
 2 #include<ctime>                                                 
 3 #include<cstdio>                                                
 4 const int MAXN = 10000000;                                      
 5 const int MAXS = 60*1024*1024;                                  
 6 int numbers[MAXN];                                              
 7 char buf[MAXS];                                                 
 8                                                                 
 9 void analyse(char *buf, int len =MAXS)                          
10 {                                                               
11         int i;                                                  
12         numbers[i=0]=0;                                         
13         for(char *p=buf;*p && p-buf<len;p++)                    
14         if(*p == ' ')                                           
15                 numbers[++i]=0;                                 
16         else                                                    
17                 numbers[i]=numbers[i]*10+*p-'0';                
18 }                                                               
19                                                                 
20 void fread_analyse()                                            
21 {                                                               
22         freopen("data.txt","rb",stdin);                         
23         int len = fread(buf,1,MAXS,stdin);                      
24         buf[len]='\0';                                          
25         analyse(buf,len);                                       
26 }                                                               
27                                                                 
28 int main ()                                                     
29 {                                                               
30         int start = clock();                                    
31         fread_analyse();                                        
32         printf("%.3lf\n",double(clock()-start)/CLOCKS_PER_SEC); 
33         return 0;                                               
34 }

时间如原文一般，大幅缩短，我这里测试得到0.37s，使用read测试，代码如下:

#include<iostream>                                             
#include<ctime>                                                
#include<cstdio>                                               
#include<unistd.h>                                             
#include<fcntl.h>                                              
const int MAXN = 10000000;                                     
const int MAXS = 60*1024*1024;                                 
int numbers[MAXN];                                             
char buf[MAXS];                                                
                                                               
void analyse(char *buf, int len =MAXS)                         
{                                                              
        int i;                                                 
        numbers[i=0]=0;                                        
        for(char *p=buf;*p && p-buf<len;p++)                   
        if(*p == ' ')                                          
                numbers[++i]=0;                                
        else                                                   
                numbers[i]=numbers[i]*10+*p-'0';               
}                                                              
                                                               
void read_analyse()                                            
{                                                              
        int fd = open("data.txt",O_RDONLY);                    
        int len = read(fd,buf,MAXS);                           
        buf[len]='\0';                                         
        analyse(buf,len);                                      
}                                                              
                                                               
int main ()                                                    
{                                                              
        int start = clock();                                   
        read_analyse();                                        
        printf("%.3lf\n",double(clock()-start)/CLOCKS_PER_SEC);
        return 0;                                              
}

测试时间为0.31s，有所进步，不过不是非常明显。
调用mmap，代码如下:

 1 #include<iostream>                                                      
 2 #include<ctime>                                                         
 3 #include<cstdio>                                                        
 4 #include<unistd.h>                                                      
 5 #include<fcntl.h>                                                       
 6 #include<sys/mman.h>                                                    
 7 const int MAXN = 10000000;                                              
 8 const int MAXS = 60*1024*1024;                                          
 9 int numbers[MAXN];                                                      
10 char buf[MAXS];                                                         
11                                                                         
12 void analyse(char *buf, int len =MAXS)                                  
13 {                                                                       
14         int i;                                                          
15         numbers[i=0]=0;                                                 
16         for(char *p=buf;*p && p-buf<len;p++)                            
17         if(*p == ' ')                                                   
18                 numbers[++i]=0;                                         
19         else                                                            
20                 numbers[i]=numbers[i]*10+*p-'0';                        
21 }                                                                       
22                                                                         
23 void mmap_analyse()                                                     
24 {                                                                       
25         int fd = open("data.txt",O_RDONLY);                             
26         int len = lseek(fd,0,SEEK_END);                                 
27         char *mbuf = (char *) mmap(NULL,len,PROT_READ,MAP_PRIVATE,fd,0);
28         analyse(mbuf,len);                                              
29 }                                                                       
30                                                                         
31 int main ()                                                             
32 {                                                                       
33         int start = clock();                                            
34         mmap_analyse();                                                 
35         printf("%.3lf\n",double(clock()-start)/CLOCKS_PER_SEC);         
36         return 0;                                                       
37 }

达到0.49s，与原文不符(原文中使用mmnp耗时更短，在我的测试中，耗时变长了)，可能是代码与原作者的不一样，原作者只给出一部分代码，而测试需要写出完整的代码，可能我写的代码有问题。
以上测试结果在腾讯云上进行,因为原作者当时的硬件条件可能比不上我所使用的环境，我在树莓派 3B和我自己的电脑上测试了一下，所有平台硬件信息如下：

硬件信息对比
平台/硬件和软件信息Cent OSRaspberryWindows
CPU1 CoreBroadcom BCM2837 1.2GHzintel Core 5200u 2.2GHz
RAM1GB1GB12GB
Gcc4.8.54.9.25.3.0

PS: 这里忽略了硬盘的性能，理论上来说，硬盘的性能肯定能影响读写速度，只是没有较好的方法比较三个平台的硬盘性能，只能作罢。不过在下面的表中我对比了我自己电脑上在Windows环境下和Linux环境下的情况。相较于原文，舍去VS的比较信息，全部使用了GNU/GCC.

测试结果如下

方法/平台/耗时(s)Cent OSRaspberryWindows(本机)Ubuntu(本机)
scanf1.18014.7864.4881.158
cin13.02661.25513.0264.309
cin(取消同步)1.2407.69480861.135
fread0.373.5030.3270.284
read0.312.9750.3700.285
mmap0.495.945NULL0.447

在同等硬件条件下，Windows比Linux慢得多，在同等环境下，硬件好的自然快，树莓派充分证明了这一点。

转载于:https://www.cnblogs.com/hushuangpu/p/6661464.html

ACM比赛中如何加速c++的输入输出？如何使cin速度与scanf速度相当？什么是最快的输入输出方法？
逍遥小章
02-02 1万+
在竞赛中，遇到大数据时，往往读文件成了程序运行速度的瓶颈，需要更快的读取方式。相信几乎所有的C++学习者都在cin机器缓慢的速度上栽过跟头，于是从此以后发誓不用cin读数据。还有人说Pascal的read语句的速度是C/C++中scanf比不上的，C++选手只能干着急。难道C++真的低Pascal一等吗？答案是不言而喻的。一个进阶的方法是把数据一下子读进来，然后再转化字符串，这种方法传说中很不错，
ACM模式输入输出攻略 | C++篇
qq_46046431的博客
02-28 2万+
本文内容干货非常非常多，从笔试面试环境的要点，到C++输入输出的具体函数，再到几乎覆盖全部情况的ACM模式写法，最后也给出了链表和二叉树的定义和输入输出。
OJ C++读取数据 cin关闭同步
Bpazy的博客
11-02 1万+
很多人会说cin的速度比scanf慢很多, 其实不然. cin慢的原因主要在于默认cin与stdin总是保持同步, 这一步是消耗时间大户. 只需要加上std::ios::sync_with_stdio(false)来关闭同步就好了, 速度甚至要优于scanf.
竞赛中应该用scanf还是cin？ scanf&printf与cin&cout的比较+快读快写
ZER00000001的博客
08-15 8587
在刷算法竞赛的时候，我们究竟是用iostream还是cstdio呢？让我们用数据说话！
scanf和cin的差异
weixin_34348174的博客
05-22 309
scanf和cin的差异 引例：http://www.cnblogs.com/shenben/p/5516996.html 大家都知道，在C++中有两种输入、输出方式—scanf和cin，但是，它们之间存在的差异，你们知道么？下面请看测评吧！ 测试题目： 输入n个数，输出n个数。 测试环境：ubuntu12.04 i3CPU 4G内存 7200转硬盘 测试结果...
【数据的输入和输出】C语言
weixin_74446734的博客
12-20 310
C语言入门简介
cin,cout与scanf,printf
DOVIS1209
03-20 5793
点击打开链接关于C/C++ stdin缓冲区以及对字符输入的一些经验和心得  在使用C/C++编写控制台应用或acm竞赛的时候，I/O方式无非是标准输入输出，特别是acm竞赛，就本人来说，由C语言入门，输入方式还只会scanf，自从学了C++，便深深地被 cin/cout输入输出流的简洁用法所吸引，相信有这种感觉的不止我一个人。   所以很长一段时间，日常的训练和各种线上比赛，再也没有使用过sca...
C++输入输出函数和底层原理详解
qq_31724803的博客
03-31 2470
关于C和C++输入输出方法的详细解释，包括cout和printf的效率问题，以及输入输出流的运行问题，适合新手和想要进一步加深输入输出理解的同学，目前理解还不是最全面的，以后有新的理解会持续更新
C/C++中的结束输入条件判断 (scanf、EOF、getchar()、cin.get()、getline)
热门推荐
Jaster_wisdom的专栏
07-23 4万+
本教程主要适用于一些程序比赛或大公司机试中的输入数据的处理，总的来说，可以分为以下三种情况： 情况一：输入的测试样例有多组，每组需要相同逻辑的处理； 处理方案：在C语言中可利用scanf("%d",&amp;n)!=EOF，在C++中可以使用while(cin&gt;&gt;n)。 例如：计算两数之和，输入可能有多组样例。 #include &lt;iostream&gt; using ...
scanf 与 cin 的区别
aizhi0169的博客
07-29 244
在论坛上看到有人提出一个如下的问题，在此总结一下。 原问题： http://topic.youkuaiyun.com/u/20110414/22/90d0606c-9876-48e4-9b69-bd8bd8a41897.html [cpp] view plaincopyprint? #include<stdio.h> intmain(...
scanf和cin的巨大差异！！！（ACmen必看！）
編程如戀 『暧昧』
10-24 2892
scanf和cin的差异 大家都知道，在C++中有两种输入、输出方式—scanf和cin，但是，它们之间存在的差异，你们知道么？下面请看测评吧！ 测试题目： 输入n个数，输出n个数。 测试环境： ubuntu12.04 i3CPU 4G内存 7200转硬盘 测试代码：（为了测试结果的正确性，保持其他部分（除输入输出）一样） scanf的代码： #in
cin/cout的性能优化和缓冲区同步问题
2301_80418172的博客
11-30 1322
IO
C/C++字符数组的输入输出方式详解（自行复习用）
m0_65305142的博客
02-09 2万+
字符是C/C++读入数据最主要的类型。本篇将介绍单个字符数组/多个字符串及二维数组的输入输出方式与相关函数。
C++数据类型运算符输入输出
波风水门的博客
02-25 1194
类类型支持封装、继承、多态特性包含成员变量与方法，如模板类型泛型编程基础，如支持类型参数化，提升代码复用性。
online_2.12-0.0.41-sources.jar
09-09
online_2.12-0.0.41-sources.jar
online_2.11-0.0.101.jar
最新发布
09-10
online_2.11-0.0.101.jar
solr-plugins-0.3-javadoc.jar
09-10
solr-plugins-0.3-javadoc.jar
sbt-shuwari-mode-0.10.1-sources.jar
09-09
sbt-shuwari-mode-0.10.1-sources.jar
catboost-spark-macros_2.12-1.0.4-javadoc.jar
09-09
catboost-spark-macros_2.12-1.0.4-javadoc.jar
北邮OJ常见问题解答：输入输出、编译器和评判机制
此外，需要注意的是，在使用G++编译器时，cin和cout对象的输入输出速度相比scanf和printf函数较慢。因此，在输入输出量较大的情况下，使用cin和cout对象可能会导致超出时间限制（TimeLimitExceed）。 问题2：这个...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值