[C/C++]快速读入代码（快读）

快读

1、为什么要有快读

好吧，有些题目看上去十分简单，例如https://www.luogu.com.cn/problem/P4305这道题，实际上数据量巨多，光是一个测试点就可能有几个MB，在这种情况下，就连scanf和printf函数都会超时Σ( ° △ °|||)︴我当初用scanf写时TLE了3个点。我才不会告诉你我是用unordered_map水过去的

所以我们需要找到另外的读入数据的方式。这时就要用到我们平时忽视的一个函数了——getchar()。你肯定会感到惊讶，但是我可以毫不犹豫地告诉你，这玩意确实比上述两个读入方式快许多。我们先一个萝卜一个坑，从读入int型开始慢慢做。

前面主要讲运行原理，如果是需要直接拿代码的，可以调到最后面去查看

2、输入int

有时输入并不会像你想的那么简单，常常会出现一些空格或回车。如果从当前字符直接开始读的话，就会多读入一些空格或者回车，导致数据出错。所以我们需要一个循环先过滤掉前面一些不需要的字符。

char ch = ' ';//初始化超重要的
while(ch < '' || ch > '')
{
    ch = getchar();//此处用ch来充当变量
}

我们似乎要考虑一个情况，如果出现负数，会怎么样？没关系，在这个循环里加入一个判断，来确定是正数还是负数：

char ch = ' ';//初始化超重要的
int w = ;//是1就是正数
while(ch < '' || ch > '')
{
    if(ch == '-') w = -;//是-1就是负数
    ch = getchar();//此处用ch来充当变量
}

我这段代码有一个隐藏BUG。先让读者观摩几分钟，然后查一查BUG。

BUG就是：如果输入数据时" -  9"，它也会判断为负数！不过没关系，很多题目的输入数据已经保证不会出现这种情况。如果还不放心，可以自己改一改（其实是我懒了）

目前已经将前面多余的字符过滤掉了，现在要处理的是后面数字部分。此时我们要引用一个新的变量s来存储所输入的数字。处理输入也很简单，不断输入直到不再是1~9之间的数：

while(ch >= '' && ch <= '')
{
   s = s *  + ch - '',//读入的数据是字符，需要减去一个ASCLL码 
   ch = getchar();
}

如此，我们最后返回数据就可以了。全代码：

inline int IntRead()//内联函数稍微快一点点
{
    char ch = getchar();
    int s = , w = ;
    while(ch < '' || ch > '')
    {
        if(ch == '-') w = -;
        ch = getchar();
    }
    while(ch >= '' && ch <= '')
    {
        s = s *  + ch - '',
        ch = getchar();
    }
    return s * w;
}

int main()
{
    int a;
    a = IntRead();
    cout << a;
}

（等会，我好像忘记打include了）

3、输入string字符串

处理完int输入，字符串输入相对来说简单多了。首先先处理完前面多余的回车与空格，然后再不断读入直到读到回车或空格。这里不再赘述直接上代码：

inline string StringRead()
{
    string str;
    char s = getchar();
    //处理多余回车或空格
    while (s == ' ' || s == '\n' || s == '\r')
    {
        s = getchar();
    }
    //不断读入直到遇到回车或空格
    while (s != ' ' && s != '\n' && s != '\r')
    {
        str += s;
        s = getchar();
    }
    return str;
}

4、读入浮点数

终于到一个稍微复杂一点的地方了，读入浮点数。读入浮点数有两个策略，1是先读入字符串然后再进行处理，2是读入的过程中，先读整数部分，然后再读小数部分。这里我选择第二种。

前面处理多余字符和判断负数的方式与int相同，只是后面读入数字过程中要改变一下。我们引入两个变量n、k和m，n存储当前是读整数部分还是小数部分，k表示小数部分的值，m表示小数部分的长度（可省略，但为了方便阅读）。（这样写或许过于复杂？）如果读到小数点，便修改n的值，否则就看n的值来读入整数或小数。

最后返回答案时，直接将k转换为小数，然后加上整数部分，然后再决定是返回负数还是正数。

代码：

inline double DoubleRead()
{
    //double的值可能很大，所以开long long
    long long s = , w = , k = , n = , m = ;
    char ch = getchar();
    //和int一毛一样有木有
    while(ch < '' || ch > '')
    {
        if(ch == '-') w = -;
        ch = getchar();
    }
    while((ch >= '' && ch <= '') || ch == '.')
    {
        //n = 0代表读入整数，= 1代表读入小数
        if (ch == '.')
            n = ;
        else if (n == )
            s = s *  + ch - '';
           else k = k *  + ch - '', m++;
        ch = getchar();
    }
    return (pow(0.1, m) * k + s) * w;
}

大致的读入方法就OK了，但是实际上我并没有对代码做优化。快速读出的代码略有麻烦，或许我以后会再写一个随笔来讲一下。用了一个下午的时间，你真的以为我只做了这些？（笑）闲得无聊的我还写了两个类来施行快速读入或读出，下面放代码：

所有代码

//FastIntput.h
#include <cstdio>
#include <string>
#include <cmath>
class FastInput
{
private:
public:
    inline friend FastInput& operator >> (FastInput& in, int& a)
    {
        int s = , w = ;
           char ch = getchar();
           while(ch < '' || ch > '')
        {
            if(ch == '-') w = -;
            ch = getchar();
        }
           while(ch >= '' && ch <= '')
           {
           s = s *  + ch - '', ch = getchar();
        }
        a = s * w;
        return in;
    }
    inline friend FastInput& operator >> (FastInput& in, long long& a)
    {
        long int s = , w = ;
           char ch = getchar();
           while(ch < '' || ch > '')
        {
            if(ch == '-') w = -;
            ch = getchar();
        }
           while(ch >= '' && ch <= '')
           {
           s = s *  + ch - '', ch = getchar();
        }
        a = s * w;
        return in;
    }
    inline friend FastInput& operator >> (FastInput& in, float& a)
    {
        long long s = , w = , k = , now = , mi = ;
           char ch = getchar();
           while(ch < '' || ch > '')
        {
            if(ch == '-') w = -;
            ch = getchar();
        }
           while((ch >= '' && ch <= '') || ch == '.')
           {
               if (ch == '.')
                   now = ;
               else if (now == )
                   s = s *  + ch - '';
               else k = k *  + ch - '', mi++;
            ch = getchar();
        }
        a = (pow(0.1, mi) * k + s) * w;
        return in;
    }
    inline friend FastInput& operator >> (FastInput& in, double& a)
    {
        long long int s = , w = , k = , now = , mi = ;
        char ch = getchar();
        while(ch < '' || ch > '')
        {
            if(ch == '-') w = -;
            ch = getchar();
        }
        while((ch >= '' && ch <= '') || ch == '.')
        {
            if (ch == '.')
                now = ;
            else if (now == )
                s = s *  + ch - '';
               else k = k *  + ch - '', mi++;
            ch = getchar();
        }
        a = (pow(0.1, mi) * k + s) * w;
        return in;
    }
    inline friend FastInput& operator >> (FastInput& in, char& ch)
    {
        ch = getchar();
        return in;
    }
    inline friend FastInput& operator >> (FastInput& in, std::string& st)
    {
        std::string str;
        char s = getchar();
        while (s == ' ' || s == '\n' || s == '\r')
        {
            s = getchar();
        }
        while (s != ' ' && s != '\n' && s != '\r')
        {
            str += s;
            s = getchar();
        }
        st = str;
        return in;
    }
};
FastInput FI;

快速读入

//FastOutPut.h
#include <cstdio>
#include <string>
class FastOutput
{
private:
public:
    inline friend FastOutput& operator << (FastOutput& out, int s)
    {
        int k = ;
        if (s == )
            putchar('');
        while (s)
        {
            k = k *  + s % ;
            s /= ;
        }
        while (k)
        {
            putchar(k %  + '');
            k /= ;
        }
        return out;
    }
    inline friend FastOutput& operator << (FastOutput& out, long long s)
    {
        long long k = ;
        if (s == )
            putchar('');
        while (s)
        {
            k = k *  + s % ;
            s /= ;
        }
        while (k)
        {
            putchar(k %  + '');
            k /= ;
        }
        return out;
    }
    inline friend FastOutput& operator << (FastOutput& out, float a)
    {
        int mi = , s[];
        if (a == )
            putchar('');
        while (a != (long long)a)
        {
            a *= , mi++;
        }
        long long k = a, i = ;
        while (k != )
        {
            s[i] = k % , i++, k /= ;
        }
        for (i -= ;i >= ;i--)
        {
            if (i == mi - )
                putchar('.');
            putchar(s[i] + '');
        }
        return out;
    }
    inline friend FastOutput& operator << (FastOutput& out, double a)
    {
        int mi = , s[];
        if (a == )
            putchar('');
        while (a != (long long int)a)
        {
            a *= , mi++;
        }
        long long int k = a, i = ;
        while (k != )
        {
            s[i] = k % , i++, k /= ;
        }
        for (i -= ;i >= ;i--)
        {
            if (i == mi - )
                putchar('.');
            putchar(s[i] + '');
        }
        return out;
    }
    inline friend FastOutput& operator << (FastOutput& out, char& ch)
    {
        putchar(ch);
        return out;
    }
    inline friend FastOutput& operator << (FastOutput& out, std::string str)
    {
        int i = ;
        while (str[i] != '\0')
        {
            putchar(str[i]), i++;
        }
        return out;
    }
};
FastOutput FO;

快速读出

inline int IntRead()
{
    char ch = getchar();
    int s = , w = ;
    while(ch < '' || ch > '')
    {
        if(ch == '-') w = -;
        ch = getchar();
    }
    while(ch >= '' && ch <= '')
    {
        s = s *  + ch - '',
        ch = getchar();
    }
    return s * w;
}

快速读入int

inline string StringRead()
{
    string str;
    char s = getchar();
    while (s == ' ' || s == '\n' || s == '\r')
    {
        s = getchar();
    }
    while (s != ' ' && s != '\n' && s != '\r')
    {
        str += s;
        s = getchar();
    }
    return str;
}

快速读入string

inline double DoubleRead()
{
    long long s = , w = , k = , n = , m = ;
    char ch = getchar();
    while(ch < '' || ch > '')
    {
        if(ch == '-') w = -;
        ch = getchar();
    }
    while((ch >= '' && ch <= '') || ch == '.')
    {
        if (ch == '.')
            n = ;
        else if (n == )
            s = s *  + ch - '';
           else k = k *  + ch - '', m++;
        ch = getchar();
    }
    return (pow(0.1, m) * k + s) * w;
}

快速读入double

...
//把那两个类复制或用include调用
int main()
{
    int a;
    long long b;
    long long int c;
    float d;
    double e;
    std::string f;
    FI >> a;
    FO << a << "\n";
    FI >> b;
    FO << b << "\n";
    FI >> c;
    FO << c << "\n";
    FI >> d;
    FO << d << "\n";
    FI >> e;
    FO << e << "\n";
    FI >> f;
    FO << f << "\n";
}

最上面俩代码用法

关于前面两个类，你没必要选择复制粘贴，而是可以用调用库的方式来调用它们。例如：

#include "FastInput.h"

最后

这一篇随笔算是比较短的，但是我还是花了一个下午的时间去码代码，但可能依旧有一些小错误。一些代码复制上来的时候我并没有仔细去检查，如果你发现了错误，欢迎在评论区里留言。