探索C++最快的读取文件的方案

最新推荐文章于 2024-05-11 10:20:16 发布
最新推荐文章于 2024-05-11 10:20:16 发布
阅读量9.8k 收藏 23
点赞数 1
分类专栏： linux网络编程 文章标签： c++ numbers pascal 测试 linux windows

http://www.byvoid.com/blog/fast-readfile/

 

http://blog.csdn.net/jifengszf/article/details/3886802

 

在竞赛中，遇到大数据时，往往读文件成了程序运行速度的瓶颈，需要更快的读取方式。相信几乎所有的C++学习者都在cin机器缓慢的速度上栽过跟头，于是从此以后发誓不用cin读数据。还有人说Pascal的read语句的速度是C/C++中scanf比不上的，C++选手只能干着急。难道C++真的低Pascal一等吗？答案是不言而喻的。一个进阶的方法是把数据一下子读进来，然后再转化字符串，这种方法传说中很不错，但具体如何从没试过，因此今天就索性把能想到的所有的读数据的方式都测试了一边，结果是惊人的。

竞赛中读数据的情况最多的莫过于读一大堆整数了，于是我写了一个程序，生成一千万个随机数到data.txt中，一共55MB。然后我写了个程序主干计算运行时间，代码如下：

 
  
1
2
3
4
5
6
7

#include <ctime>
int main()
{
	int start = clock();
	//DO SOMETHING
	printf("%.3lf\n",double(clock()-start)/CLOCKS_PER_SEC);
}

最简单的方法就算写一个循环scanf了，代码如下：

1
2
3
4
5
6
7
8
9
10

const int MAXN = 10000000;
 
int numbers[MAXN];
 
void scanf_read()
{
	freopen("data.txt","r",stdin);
	for (int i=0;i<MAXN;i++)
		scanf("%d",&numbers[i]);
}

可是效率如何呢？在我的电脑Linux平台上测试结果为2.01秒。接下来是cin，代码如下

1
2
3
4
5
6
7
8
9
10

const int MAXN = 10000000;
 
int numbers[MAXN];
 
void cin_read()
{
	freopen("data.txt","r",stdin);
	for (int i=0;i<MAXN;i++)
		std::cin >> numbers[i];
}

出乎我的意料，cin仅仅用了6.38秒，比我想象的要快。cin慢是有原因的，其实默认的时候，cin与stdin总是保持同步的，也就是说这两种方法可以混用，而不必担心文件指针混乱，同时cout和stdout也一样，两者混用不会输出顺序错乱。正因为这个兼容性的特性，导致cin有许多额外的开销，如何禁用这个特性呢？只需一个语句std::ios::sync_with_stdio(false);，这样就可以取消cin于stdin的同步了。程序如下：

1
2
3
4
5
6
7
8
9
10
11

const int MAXN = 10000000;
 
int numbers[MAXN];
 
void cin_read_nosync()
{
	freopen("data.txt","r",stdin);
	std::ios::sync_with_stdio(false);
	for (int i=0;i<MAXN;i++)
		std::cin >> numbers[i];
}

取消同步后效率究竟如何？经测试运行时间锐减到了2.05秒，与scanf效率相差无几了！有了这个以后可以放心使用cin和cout了。

接下来让我们测试一下读入整个文件再处理的方法，首先要写一个字符串转化为数组的函数，代码如下

1
2
3
4
5
6
7
8
9
10
11
12
13

const int MAXS = 60*1024*1024;
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';
}

把整个文件读入一个字符串最常用的方法是用fread，代码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13

const int MAXN = 10000000;
const int MAXS = 60*1024*1024;
 
int numbers[MAXN];
char buf[MAXS];
 
void fread_analyse()
{
	freopen("data.txt","rb",stdin);
	int len = fread(buf,1,MAXS,stdin);
	buf[len] = '\0';
	analyse(buf,len);
}

上述代码有着惊人的效率，经测试读取这10000000个数只用了0.29秒，效率提高了几乎10倍！掌握着种方法简直无敌了，不过，我记得fread是封装过的read，如果直接使用read，是不是更快呢？代码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13

const int MAXN = 10000000;
const int MAXS = 60*1024*1024;
 
int numbers[MAXN];
char buf[MAXS];
 
void read_analyse()
{
	int fd = open("data.txt",O_RDONLY);
	int len = read(fd,buf,MAXS);
	buf[len] = '\0';
	analyse(buf,len);
}

测试发现运行时间仍然是0.29秒，可见read不具备特殊的优势。到此已经结束了吗？不，我可以调用Linux的底层函数mmap，这个函数的功能是将文件映射到内存，是所有读文件方法都要封装的基础方法，直接使用mmap会怎样呢？代码如下：

1
2
3
4
5
6
7
8
9
10
11
12

const int MAXN = 10000000;
const int MAXS = 60*1024*1024;
 
int numbers[MAXN];
char buf[MAXS];
void mmap_analyse()
{
	int fd = open("data.txt",O_RDONLY);
	int len = lseek(fd,0,SEEK_END);
	char *mbuf = (char *) mmap(NULL,len,PROT_READ,MAP_PRIVATE,fd,0);	
	analyse(mbuf,len);
}

经测试，运行时间缩短到了0.25秒，效率继续提高了14%。到此为止我已经没有更好的方法继续提高读文件的速度了。回头测一下Pascal的速度如何？结果令人大跌眼镜，居然运行了2.16秒之多。程序如下：

? View Code PASCAL 
1
2
3
4
5
6
7
8
9
10
11

const
	MAXN = 10000000;
var
	numbers :array[0..MAXN] of longint;
	i :longint;
begin
	assign(input,'data.txt');
	reset(input);
	for i:=0 to MAXN do
		read(numbers[i]);
end.

为确保准确性，我又换到Windows平台上测试了一下。结果如下表：

方法/平台/时间(秒)Linux gccWindows mingwWindows VC2008
scanf2.0103.7043.425
cin6.38064.00319.208
cin取消同步2.0506.00419.616
fread0.2900.2410.304
read0.2900.398不支持
mmap0.250不支持不支持
Pascal read2.1604.668 

从上面可以看出几个问题

  1. Linux平台上运行程序普遍比Windows上快。
  2. Windows下VC编译的程序一般运行比MINGW（MINimal Gcc for Windows）快。
  3. VC对cin取消同步与否不敏感，前后效率相同。反过来MINGW则非常敏感，前后效率相差8倍。
  4. read本是linux系统函数，MINGW可能采用了某种模拟方式，read比fread更慢。
  5. Pascal程序运行速度实在令人不敢恭维

 

 

 

在竞赛中，遇到大数据时，往往读文件成了程序运行速度的瓶颈，需要更快的读取方式。相信几乎所有的C++学习者都在cin机器缓慢的速度上栽过跟头，于是从此以后发誓不用cin读数据。还有人说Pascal的read语句的速度是C/C++中scanf比不上的，C++选手只能干着急。难道C++真的低Pascal一等吗？答案是不言而喻的。一个进阶的方法是把数据一下子读进来，然后再转化字符串，这种方法传说中很不错，但具体如何从没试过，因此今天就索性把能想到的所有的读数据的方式都测试了一边，结果是惊人的。

竞赛中读数据的情况最多的莫过于读一大堆整数了，于是我写了一个程序，生成一千万个随机数到data.txt中，一共55MB。然后我写了个程序主干计算运行时间，代码如下：

? View Code CPP 
1
2
3
4
5
6
7

#include <ctime>
int main()
{
	int start = clock();
	//DO SOMETHING
	printf("%.3lf\n",double(clock()-start)/CLOCKS_PER_SEC);
}

最简单的方法就算写一个循环scanf了，代码如下：

? View Code CPP 
1
2
3
4
5
6
7
8
9
10

const int MAXN = 10000000;
 
int numbers[MAXN];
 
void scanf_read()
{
	freopen("data.txt","r",stdin);
	for (int i=0;i<MAXN;i++)
		scanf("%d",&numbers[i]);
}

可是效率如何呢？在我的电脑Linux平台上测试结果为2.01秒。接下来是cin，代码如下

? View Code CPP 
1
2
3
4
5
6
7
8
9
10

const int MAXN = 10000000;
 
int numbers[MAXN];
 
void cin_read()
{
	freopen("data.txt","r",stdin);
	for (int i=0;i<MAXN;i++)
		std::cin >> numbers[i];
}

出乎我的意料，cin仅仅用了6.38秒，比我想象的要快。cin慢是有原因的，其实默认的时候，cin与stdin总是保持同步的，也就是说这两种方法可以混用，而不必担心文件指针混乱，同时cout和stdout也一样，两者混用不会输出顺序错乱。正因为这个兼容性的特性，导致cin有许多额外的开销，如何禁用这个特性呢？只需一个语句std::ios::sync_with_stdio(false);，这样就可以取消cin于stdin的同步了。程序如下：

? View Code CPP 
1
2
3
4
5
6
7
8
9
10
11

const int MAXN = 10000000;
 
int numbers[MAXN];
 
void cin_read_nosync()
{
	freopen("data.txt","r",stdin);
	std::ios::sync_with_stdio(false);
	for (int i=0;i<MAXN;i++)
		std::cin >> numbers[i];
}

取消同步后效率究竟如何？经测试运行时间锐减到了2.05秒，与scanf效率相差无几了！有了这个以后可以放心使用cin和cout了。

接下来让我们测试一下读入整个文件再处理的方法，首先要写一个字符串转化为数组的函数，代码如下

? View Code CPP 
1
2
3
4
5
6
7
8
9
10
11
12
13

const int MAXS = 60*1024*1024;
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';
}

把整个文件读入一个字符串最常用的方法是用fread，代码如下：

? View Code CPP 
1
2
3
4
5
6
7
8
9
10
11
12
13

const int MAXN = 10000000;
const int MAXS = 60*1024*1024;
 
int numbers[MAXN];
char buf[MAXS];
 
void fread_analyse()
{
	freopen("data.txt","rb",stdin);
	int len = fread(buf,1,MAXS,stdin);
	buf[len] = '\0';
	analyse(buf,len);
}

上述代码有着惊人的效率，经测试读取这10000000个数只用了0.29秒，效率提高了几乎10倍！掌握着种方法简直无敌了，不过，我记得fread是封装过的read，如果直接使用read，是不是更快呢？代码如下：

? View Code CPP 
1
2
3
4
5
6
7
8
9
10
11
12
13

const int MAXN = 10000000;
const int MAXS = 60*1024*1024;
 
int numbers[MAXN];
char buf[MAXS];
 
void read_analyse()
{
	int fd = open("data.txt",O_RDONLY);
	int len = read(fd,buf,MAXS);
	buf[len] = '\0';
	analyse(buf,len);
}

测试发现运行时间仍然是0.29秒，可见read不具备特殊的优势。到此已经结束了吗？不，我可以调用Linux的底层函数mmap，这个函数的功能是将文件映射到内存，是所有读文件方法都要封装的基础方法，直接使用mmap会怎样呢？代码如下：

? View Code CPP 
1
2
3
4
5
6
7
8
9
10
11
12

const int MAXN = 10000000;
const int MAXS = 60*1024*1024;
 
int numbers[MAXN];
char buf[MAXS];
void mmap_analyse()
{
	int fd = open("data.txt",O_RDONLY);
	int len = lseek(fd,0,SEEK_END);
	char *mbuf = (char *) mmap(NULL,len,PROT_READ,MAP_PRIVATE,fd,0);	
	analyse(mbuf,len);
}

经测试，运行时间缩短到了0.25秒，效率继续提高了14%。到此为止我已经没有更好的方法继续提高读文件的速度了。回头测一下Pascal的速度如何？结果令人大跌眼镜，居然运行了2.16秒之多。程序如下：

? View Code PASCAL 
1
2
3
4
5
6
7
8
9
10
11

const
	MAXN = 10000000;
var
	numbers :array[0..MAXN] of longint;
	i :longint;
begin
	assign(input,'data.txt');
	reset(input);
	for i:=0 to MAXN do
		read(numbers[i]);
end.

为确保准确性，我又换到Windows平台上测试了一下。结果如下表：

 

方法/平台/时间(秒)Linux gccWindows mingwWindows VC2008
scanf2.0103.7043.425
cin6.38064.00319.208
cin取消同步2.0506.00419.616
fread0.2900.2410.304
read0.2900.398不支持
mmap0.250不支持不支持
Pascal read2.1604.668 

从上面可以看出几个问题

  1. Linux平台上运行程序普遍比Windows上快。
  2. Windows下VC编译的程序一般运行比MINGW（MINimal Gcc for Windows）快。
  3. VC对cin取消同步与否不敏感，前后效率相同。反过来MINGW则非常敏感，前后效率相差8倍。
  4. read本是linux系统函数，MINGW可能采用了某种模拟方式，read比fread更慢。
  5. Pascal程序运行速度实在令人不敢恭维。

希望此文能对大家有所启发，欢迎与我继续讨论。

一. 文件一次读入速度

linux下读文件这东西最后都是要通过系统调用sys_read(fd,buf,count)来实现的，所以如果要提高速度，就是最简单地调用sys_read的封装，比如直接用read()或fread()。下面是我在linux下的几个测试。

首先创建一个130M数据文件 dd if=/dev/zero of=data bs=1024k count=130
分别用fread,read和fgets一次读入全部大小文件所消耗时间对比,其中
size=130*1024*1024
char *buf=new char[size];

下面是测试结果(机器Intel(R) Pentium(R) 4 CPU 3.20GHz, Mem 1G):
1.fread(buf,size,1,fp)一次读入
real    0m0.187s
user    0m0.000s
sys     0m0.180s

2.read(fdin,(void *)buf,size)一次读入
real    0m0.187s
user    0m0.000s
sys     0m0.184s

3.多次fgets(buf,size,fp),每次1k
real    0m0.356s
user    0m0.136s
sys     0m0.220s

4.fgets(buf,size,fp)一次读入
real    0m0.305s
user    0m0.072s
sys     0m0.232s

上 面看到越简单的函数(read()和fread())，速度越快，其他的输入封装函数只不过是为了方便满足特殊需要，并不见得读的速度会很快。对于3和4,因为在sys_read()内部有对读入大小的判断和while循环，所以大文件读取也没必要像3那样分多次调用fgets()来读文件.

另外用mmap()内存映射来读入文件的时间如下:
real    0m0.231s
user    0m0.068s
sys     0m0.164s

也并没有比直接read()快，网上找到一种解释是对于需要频繁读写操作的，mmap效率才会显著提高。下面来模拟频繁读写操作。

二. 文件频繁读写速度测试

1. 这一个测试模拟频繁文件读写操作，500M大小的数据文件data.in，每次从中读入1k个字节对每个字节做加1简单计算，再写到另一个文件data.out中。
//mmapx1.c
#define size 1024*1024*500
#define LEN 1024
#include <stdio.h>
int main()
{
    FILE *fp1,*fp2;
    char *buf=new char[LEN];
    int i,j;
    fp1=fopen("data.in","rb");
    fp2=fopen("data.out","wb");
    for(j=0;j<1024*500;j++)
    {
        fread(buf,1024,1,fp1);
        for(i=0;i<LEN;i++)
            buf[i]++;
        fwrite(buf,LEN,1,fp2);
    }
    printf("ok!/n");
    fclose(fp1);
    fclose(fp2);
}
time 命令测试时间，每次结果都不一样，机器负载有关。5次输出的结果如下:
real 19.592s     18.517s     18.003s     20.470s     20.004s
usr 2.924s       2.964s       3.000s       2.812s       2.972s
sys 2.472s       2.360s       2.344s       2.652s       0.396s

2. 如果采用内存映射，将文件data.in映射到存储区，就避免的对文件的频繁读写操作，而全部转变为I/O存储读写。下面一个程序就是用mmap映射将文件data.in中每个数据加1存储到data.out中。
//mmapx2.c
#include <stdio.h>
#include <fcntl.h>
#include <string.h>
#include <sys/mman.h>
#include <unistd.h>
#define size 1024*1024*500
#define LEN 1024
int main()
{
    int fdin,fdout;
    struct stat statbuf;
    void *src,*dst;
    char *p;
    int i,j;
    fdin=open("data.in",O_RDONLY);
    fdout=open("data.out",O_RDWR|O_CREAT|O_TRUNC);

    if((src=mmap(0,size,PROT_READ,MAP_SHARED,fdin,0))==MAP_FAILED)
    {
        printf("src map error/n");
        return -1;
    }
    lseek(fdout,size-1,SEEK_SET);
    write(fdout,"/0",1);
   //因为data.out是空文件，必须创建一个空洞让其大小成为size来进行下面的mmap

    if((dst=mmap(0,size,PROT_READ|PROT_WRITE,MAP_SHARED,fdout,0))==MAP_FAILED)
    {
        printf("dest map error/n");
        return -1;
    }
        memcpy(dst,src,size);
        p=(char*)dst;
    for(i=0;i<size/LEN;i++)
    {
        for(j=0;j<LEN;j++)
            p[j]++;
        p+=LEN;
    }
    printf("ok/n");
    close(fdout);
    return 0;
}
time测试的5次运行时间如下:
real  9.603s      8.977s      9.416s      9.587s      9.322s
usr  2.764s      2.748s      2.784s      2.840s      2.787s
sys  1.516s      1.384s      1.384s      1.224s      1.276s

结论：上面可以看到，对于频繁IO读写，采用mmap存储映射可以有效提高效率(20s到9s)

3.mmap内存映射还有一个好处，就是直接在一个文件内任意读写修改某个字节，就像操作存储区一样，比如下面一段程序是实现对data.in中每个字节数据加1的计算。

//mmapx3.c
#include <stdio.h>
#include <fcntl.h>
#include <string.h>
#include <sys/mman.h>
#include <unistd.h>
#define size 1024*1024*500
#define LEN 1024
int main()
{
    int fd;
    void *src;
    char *p;
    int i,j;
    fd=open("data.in",O_RDWR);
    if((src=mmap(0,size,PROT_READ|PROT_WRITE,MAP_SHARED,fd,0))==MAP_FAILED)
    {
        printf("src map error/n");
        return -1;
    }
    p=(char*)src;
    for(i=0;i<size/LEN;i++)
    {
        for(j=0;j<LEN;j++)
            p[j]++;
        p+=LEN;
    }
    printf("ok/n");
    close(fd);
}
time测试的5次的运行时间如下:
real 2.820s     2.828s     2.856s     2.818s     2.889s
usr 2.624s     2.624s     2.676s     2.648s     2.584s
sys 0.196s     0.196s     0.176s     0.172s     0.288s

上面对一个大文件内的所有字节各自改变加1，并保存在原来的文件中，采用mmap存储映射的方法可以大大提高效率。对于频繁地随机改写某个文件内的某些部分字节内容的情况来说，这是一个有效的选择。

 

yaxf999
关注
  • 1
    点赞
  • 踩
  • 23
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
C++快速读写
处_的博客
08-04 1715
C++ 快速读写
【Sys】C++怎样读取文件才有最快的速度？
bandaoyu的note
06-24 4103
mmap 分析：https://sq.163yun.com/blog/article/173146709806518272 在进行大规模数据处理时，读文件很有可能成为速度瓶颈。不管你的CPU有4个核还是8个核，主频有2G还是3G，硬盘IO速度总是有个上限的。在本人最近的一次经历中，对一个11G的文本进行数据处理，一共耗时34.8秒，其中竟然有30.2秒用在访问IO上，占了所有时间的87%左右。 虽然说硬盘IO是有上限的，那么C++为我们提供的各函数，是否都能让我们达到这个上限...
C++ 加速（卡常）技巧【超级 快读、快写】
绿树公司的博客
04-18 2241
C++\texttt{C++}C++ 加速技巧 快读快写 快读 inline int read() { int x = 0, w = 0; char ch = 0; while (!isdigit(ch)) {w |= ch == '-'; ch = getchar();} while (isdigit(ch)) {x = (x << 3) + (x << 1) + (ch ^ 48); ch = getchar();} return w ? -x :
c++快读快写
最新发布
2301_80718054的博客
05-11 189
一个一个字符读取比读入一个数字（int）快。
C++快读和快写
m0_73020012的博客
10-01 4193
虽然读入优化好像用处不大，但是还是能够在读入数据规模较大的时候提供较大的优化，比如：用cin输出2000个100000000用快输输出2000个100000000单位都是毫秒。可以直观的发现，用快输的话输出时间优化了很多，那么快读是如何做到这样的呢？
关于c++输入的那些事(含超级快读)
白麟的博客
09-14 1289
一种比快读还要快的超级快读
OI中好用的技巧——c++快读快写
weixin_45940369的博客
07-14 751
c++读写速度 ： 普通写法 < scanf和printf写法 ≈ 缓存禁用写法 < 字符处理写法。在写一些题时，发现不对读写进行处理会 TLE or WA。缓存禁用写法（至少我是这么称呼的，也挺快）scanf和printf写法（快多了）字符处理写法（真正的快读快写）此时就需要降低读写的时间。普通写法（读写最慢）
C/C++中最快、最简洁的read()快读(卡常数)方法
热门推荐
tkzlfg的博客
11-28 2万+
别人的方法 遇到数据较多的OI题时，用scanf或者cin肯定是不够快的。于是，有人发明了像这样的快速读入函数： inline void read(int& a) { int s = 0, w = 1; char ch = getchar(); while (ch < '0' || ch>'9') { if (ch == '-') w = -1; ch = getchar(); } while (ch >= '0' && ch <=
探寻C++最快的读取文件的方案 C++ IO优化
08-12
探索了文件的快速读取方法， 非常详细地比较了scanf、cin、fread、read、mmap、Pascal read的读取速度
EQ-example.rar_EQ_EQ2003-11一卡通_EQ一卡通_一卡通 C++
09-23
《EQ一卡通二次开发详解——基于C++的实践与理论》 在信息技术日新月异的今天，一卡通系统已经成为各类场所，如学校...开发者需要不断学习和探索，才能在这一领域游刃有余，打造出更加符合用户需求的一卡通解决方案。
一个C++轻量基础库
11-29
《C++轻量基础库深度探索》 C++是一种强大且灵活的编程语言，尤其在底层系统编程和高性能计算领域有着广泛的应用。本篇将详细探讨一个名为“klib”的C++轻量基础库，该库包含了字符串处理、字符编码转换以及DES加密...
均值背景结合三帧差分的目标检测
03-25
- `.sln`文件：这是Visual Studio解决方案文件，包含了项目的所有相关信息，包括源代码、配置设置等。 - `Debug`目录：包含项目在调试模式下编译生成的可执行文件和其他相关文件。 - `.vs`目录：Visual Studio的...
LINUX学习资料
10-22
10. **/proc** - 提供了系统信息查询接口，信息直接从内存读取，无需磁盘读写。 11. **/root** - 超级用户(root)的家目录。 12. **/tmp** - 用于存储程序运行时生成的临时文件。 13. **/usr** - 用户应用程序的主要...
C++ CreateFileMapping 内存映射实现快速读取文件
hml111666的博客
07-08 9249
共享内存的方式原理就是将一份物理内存映射到不同进程各自的虚拟地址空间上，这样每个进程都可以读取同一份数据，从而实现进程通信。因为是通过内存操作实现通信，因此是一种最高效的数据交换方法。本文主要讲述的使用内存映射文件的目的是访问磁盘上的数据文件。你可以不必对文件执行I / O操作，并且可以不必对文件内容进行缓存。1、CreateFileMapping// 创建一个内存映射文件的内核对象 2、MapViewOfFile // 将内存映射文件映射到进程的虚拟地址中 3、OpenFileMapping //
C++ freopen 打开txt文件，读取，写入txt文件
AKGWSB 's blog
03-08 6625
需要stdio头 freopen属于输入输出流的重定向，一般我们默认的输入流是在黑黑的控制台，但是我们也可以选择从一个txt文本中读取信息，这和我们键入控制台是一样的，相当于把txt的内容拷贝到控制台 参数 /* param filePath : 文件路径(string) param mode : 模式 r=读 w=写(string) param stream : 重定向到那个流 std...
【C++常用函数】快读
qq_62618109的博客
11-04 348
目前，有许多快读的方法，但是他们通常会用到register和inline，而这篇文章是很容易理解和记忆的。如果您有更好地算法，欢迎反馈。
C++ 快读
justin666888的博客
05-11 1603
C++ 快读前言输入的优化最简单的输入优化1优化2优化3优化4快读的Bug 前言 众所周知，C++是有读入的(废话) 但是一些特别毒瘤的题目会卡输入输出，那么，我们应该怎么优化呢？请看这篇文章 输入的优化 最简单的输入 C++有一个输入方法就是cin，示例： int x; cin>>x; 简单，但是有些慢~~~~ 优化1 使用头文件 #include<cstdio> 中的 scanf 来完成输入 例子： int x; scanf("%d",&x); 优化2 还是有点慢
c++快读程序
m0_72639810的博客
07-17 376
快读即快速读入，因为getchar比scanf要快，所以可以用getchar()代替scanf。利用getchar()将输入的数字挨个判断，第一个while判断符号正负；第二个while判断数字并进行该数字的运算，每读入一个数字就将之前的数乘以十加上这个新的数字；两个while都不符合就说明该数输入完毕，返回该数的总值即绝对值*符号位。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值