Fastio

已于 2022-01-29 16:11:56 修改
阅读量227 收藏 1
点赞数
文章标签： Fastio
于 2021-08-07 00:11:05 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_46258139/article/details/119465730
版权

好用的快读

快读 1 1 1

struct Fastio
{
    template <typename T>
    inline Fastio operator>>(T &x)
    {
        x = 0;
        char c = getchar();
        while (c < '0' || c > '9')
            c = getchar();
        while (c >= '0' && c <= '9')
            x = (x << 3) + (x << 1) + (c ^ 48), c = getchar();
        return *this;
    }
    template <typename T>
    inline Fastio operator>>(T &x)
    {
        x = 0;
        char c = getchar();
        while (c < '0' || c > '9')
            c = getchar();
        while (c >= '0' && c <= '9')
            x = (x << 3) + (x << 1) + (c ^ 48), c = getchar();
        return *this;
    }
} io;

快读 2 2 2

增加字符和字符串。

struct Fastio
{
    template <typename T>
    inline Fastio operator>>(T &x)
    {
        x = 0;
        char c = getchar();
        while (c < '0' || c > '9')
            c = getchar();
        while (c >= '0' && c <= '9')
            x = (x << 3) + (x << 1) + (c ^ 48), c = getchar();
        return *this;
    }
	inline Fastio &operator<<(const char c)
    {
        putchar(c);
        return *this;
    }
    inline Fastio &operator<<(const char *str)
    {
        int cur = 0;
        while (str[cur])putchar(str[cur++]);
        return *this;
    }
    template <typename T>
    inline Fastio &operator<<(T x)
    {
        if (x == 0)
        {
            putchar('0');
            return *this;
        }
        if (x < 0) putchar('-'), x = -x;
        static int sta[45];
        int top = 0;
        while (x) sta[++top] = x % 10, x /= 10;
        while (top) putchar(sta[top] + '0'), --top;
        return *this;
    }

} io;

快读 3 3 3

在快读 1 1 1 的基础上重定义 getchar() 和 putchar()。

namespace fastio
{
	int len = 0;
    char ibuf[(1 << 20) + 1], *iS, *iT, out[(1 << 23) + 1];
    #if ONLINE_JUDGE
    #define getchar() (iS == iT) ? iT = (iS = ibuf) + fread(ibuf, 1, (1 << 20) + 1, stdin), (iS == iT ? EOF : *iS++) : *iS++)
    int read()
    {
    	int x = 0, t = 0;
    	char c = getchar();
    	while(c < '0' || c > '9')
    	{
    		t |= ch == '-';
    		c = getchar();
		}
		while(c >= '0' && c <= '9')
		{
			x = (x << 3) + (x << 1) + (c ^ 48);
			c = getchar();
		}
		return t ? -x : x;
	}
	char getcA()
	{
		char c = getchar();
		while(c < 'A' || c > 'Z') c = getchar();
		return c;
	}
	char getca()
	{
		char c = getchar();
		while(c < 'a' || c > 'z') c = getchar();
		return c;
	}
	void putc(char c)
	{
		out[len++] = c;
	}
	void write(int x)
	{
		it(x < 0) putc('-'), x = -x;
		if(x > 9) write(x / 10);
		putc(x % 10 + 48);
	}
	struct af
	{
		~af()
		{
			fwrite(out, 1, len, stdout);
			len = 0;
		}
	}Af;
}

using namespace fastio;

快读 4 4 4

复杂度巨大。


/* --------------- fast io --------------- */ // begin
namespace Fastio
{
    namespace Fread
    {
        const int SIZE = 1 << 21;
        char buf[SIZE], *S, *T;
        inline char getchar()
        {
            if (S == T)
            {
                T = (S = buf) + fread(buf, 1, SIZE, stdin);
                if (S == T)
                    return '\n';
            }
            return *S++;
        }
    } // namespace Fread
    namespace Fwrite
    {
        const int SIZE = 1 << 21;
        char buf[SIZE], *S = buf, *T = buf + SIZE;
        inline void flush()
        {
            fwrite(buf, 1, S - buf, stdout);
            S = buf;
        }
        inline void putchar(char c)
        {
            *S++ = c;
            if (S == T)
                flush();
        }
        struct NTR
        {
            ~NTR() { flush(); }
        } ztr;
    } // namespace Fwrite
#ifdef ONLINE_JUDGE
#define getchar Fread ::getchar
#define putchar Fwrite ::putchar
#endif
    struct Reader
    {
        template <typename T>
        Reader &operator>>(T &x)
        {
            char c = getchar();
            T f = 1;
            while (c < '0' || c > '9')
            {
                if (c == '-')
                    f = -1;
                c = getchar();
            }
            x = 0;
            while (c >= '0' && c <= '9')
            {
                x = x * 10 + (c - '0');
                c = getchar();
            }
            x *= f;
            return *this;
        }
        Reader &operator>>(char &c)
        {
            c = getchar();
            while (c == ' ' || c == '\n')
            {
                c = getchar();
            }
            return *this;
        }
        Reader &operator>>(char *str)
        {
            int len = 0;
            char c = getchar();
            while (c == ' ' || c == '\n')
            {
                c = getchar();
            }
            while (c != ' ' && c != '\n' && c != '\r')
            { // \r\n in windows
                str[len++] = c;
                c = getchar();
            }
            str[len] = '\0';
            return *this;
        }
        Reader() {}
    } cin;
    const char endl = '\n';
    struct Writer
    {
        template <typename T>
        Writer &operator<<(T x)
        {
            if (x == 0)
            {
                putchar('0');
                return *this;
            }
            if (x < 0)
            {
                putchar('-');
                x = -x;
            }
            static int sta[111];
            int top = 0;
            while (x)
            {
                sta[++top] = x % 10;
                x /= 10;
            }
            while (top)
            {
                putchar(sta[top] + '0');
                --top;
            }
            return *this;
        }
        Writer &operator<<(char c)
        {
            putchar(c);
            return *this;
        }
        Writer &operator<<(char *str)
        {
            int cur = 0;
            while (str[cur])
                putchar(str[cur++]);
            return *this;
        }
        Writer &operator<<(const char *str)
        {
            int cur = 0;
            while (str[cur])
                putchar(str[cur++]);
            return *this;
        }
        Writer() {}
    } cout;
#define cin Fastio ::cin
#define cout Fastio ::cout
#define endl Fastio ::endl
} // namespace Fastio

/* --------------- fast io --------------- */ // end

快读 5 5 5

支持高精度运算和高精度快读，但不支持高精度位运算。



const int N = 1e4 + 5;
struct GJ
{
    int d[N];
    int len;
    void clean()
    {
        while (len > 1 && !d[len - 1])
            len--;
    }
    GJ()
    {
        memset(d, 0, sizeof d);
    }
    GJ(int num)
    {
        *this = num;
    }
    GJ(char *num)
    {
        *this = num;
    }
    GJ operator=(const char *num)
    {
        memset(d, 0, sizeof d);
        len = strlen(num);
        for (int i = 0; i < len; i++)
            d[i] = num[len - 1 - i] - '0';
        clean();
        return *this;
    }
    GJ operator=(int num)
    {
        char s[101];
        sprintf(s, "%d", num);
        *this = s;
        return *this;
    }
    GJ operator=(long long num)
    {
        char s[202];
        sprintf(s, "%lld", num);
        *this = s;
        return *this;
    }
    GJ operator=(string num)
    {
        memset(d, 0, sizeof d);
        len = num.length();
        for (int i = 0; i < len; i++)
            d[i] = num[len - 1 - i] - '0';
        clean();
        return *this;
    }
    GJ operator+(const GJ &b)
    {
        GJ c = *this;
        int i;
        for (i = 0; i < b.len; i++)
        {
            c.d[i] += b.d[i];
            if (c.d[i] > 9)
            {
                c.d[i] %= 10;
                c.d[i + 1]++;
            }
        }
        while (c.d[i] > 9)
        {
            c.d[i++] %= 10;
            c.d[i]++;
        }
        c.len = max(len, b.len);
        if (c.d[i] && c.len <= i)
            c.len = i + 1;
        return c;
    }
    GJ operator-(const GJ &b)
    {
        GJ c = *this;
        int i;
        for (i = 0; i < b.len; i++)
        {
            c.d[i] -= b.d[i];
            if (c.d[i] < 0)
            {
                c.d[i] += 10;
                c.d[i + 1]--;
            }
        }
        while (c.d[i] < 0)
        {
            c.d[i++] += 10;
            c.d[i]--;
        }
        c.clean();
        return c;
    }
    GJ operator*(const GJ &b) const
    {
        int i, j;
        GJ c;
        c.len = len + b.len;
        for (j = 0; j < b.len; j++)
            for (i = 0; i < len; i++)
                c.d[i + j] += d[i] * b.d[j];
        for (i = 0; i < c.len - 1; i++)
        {
            c.d[i + 1] += c.d[i] / 10;
            c.d[i] %= 10;
        }
        c.clean();
        return c;
    }
    GJ operator/(const GJ &b)
    {
        int i, j;
        GJ c = *this, a = 0;
        for (i = len - 1; i >= 0; i--)
        {
            a = a * 10 + d[i];
            for (j = 0; j < 10; j++)
            {
                if (a < b * (j + 1))
                    break;
            }
            c.d[i] = j;
            a = a - b * j;
        }
        c.clean();
        return c;
    }
    GJ operator%(const GJ &b)
    {
        int i, j;
        GJ a = 0;
        for (i = len - 1; i >= 0; i--)
        {
            a = a * 10 + d[i];
            for (j = 0; j < 10; j++)
            {
                if (a < b * (j + 1))
                    break;
            }
            a = a - b * j;
        }
        return a;
    }
    GJ operator+=(const GJ &b)
    {
        *this = *this + b;
        return *this;
    }
    GJ operator-=(const GJ &b)
    {
        *this = *this - b;
        return *this;
    }
    bool operator<(const GJ &b) const
    {
        if (len != b.len)
            return len < b.len;
        for (int i = len - 1; i >= 0; i--)
            if (d[i] != b.d[i])
                return d[i] < b.d[i];
        return false;
    }
    bool operator>(const GJ &b) const { return b < *this; }
    bool operator<=(const GJ &b) const { return !(b < *this); }
    bool operator>=(const GJ &b) const { return !(*this < b); }
    bool operator!=(const GJ &b) const { return b < *this || *this < b; }
    bool operator==(const GJ &b) const { return !(b < *this) && !(b > *this); }
    string str() const
    {
        char s[N] = {};
        for (int i = 0; i < len; i++)
            s[len - 1 - i] = d[i] + '0';
        return s;
    }
};
/* --------------- fast io --------------- */ // begin
namespace Fread
{
    const int SIZE = 1 << 21;
    char buf[SIZE], *S, *T;
    inline char getchar()
    {
        if (S == T)
        {
            T = (S = buf) + fread(buf, 1, SIZE, stdin);
            if (S == T)
                return '\n';
        }
        return *S++;
    }
} // namespace Fread
namespace Fwrite
{
    const int SIZE = 1 << 21;
    char buf[SIZE], *S = buf, *T = buf + SIZE;
    inline void flush()
    {
        fwrite(buf, 1, S - buf, stdout);
        S = buf;
    }
    inline void putchar(char c)
    {
        *S++ = c;
        if (S == T)
            flush();
    }
    struct NTR
    {
        ~NTR() { flush(); }
    } ztr;
} // namespace Fwrite
#ifdef ONLINE_JUDGE
#define getchar Fread ::getchar
#define putchar Fwrite ::putchar
#endif
namespace Fastio
{
    struct Doublee
    {
        double x;
        int k = 6;
    };
    struct Reader
    {
        template <typename T>
        Reader &operator>>(T &x)
        {
            char c = getchar();
            T f = 1;
            while (c < '0' || c > '9')
            {
                if (c == '-')
                    f = -1;
                c = getchar();
            }
            x = 0;
            while (c >= '0' && c <= '9')
            {
                x = x * 10 + (c - '0');
                c = getchar();
            }
            x *= f;
            return *this;
        }
        Reader &operator>>(double &num)
        {
            char in;
            double Dec = 0.1;
            bool IsN = false, IsD = false;
            in = getchar();
            if (in == EOF)
            {
                return *this;
            }
            while (in != '-' && in != '.' && (in < '0' || in > '9'))
            {
                in = getchar();
            }
            if (in == '-')
            {
                IsN = true;
                num = 0;
            }
            else if (in == '.')
            {
                IsD = true;
                num = 0;
            }
            else
            {
                num = in - '0';
            }
            if (!IsD)
            {
                while (in = getchar(), in >= '0' && in <= '9')
                {
                    num *= 10;
                    num += in - '0';
                }
            }
            if (in != '.')
            {
                if (IsN)
                    num = -num;
            }
            else
            {
                while (in = getchar(), in >= '0' && in <= '9')
                {
                    num += Dec * (in - '0');
                    Dec *= 0.1;
                }
            }
            if (IsN)
            {
                num = -num;
            }
        }
        Reader &operator>>(char &c)
        {
            c = getchar();
            while (c == ' ' || c == '\n')
            {
                c = getchar();
            }
            return *this;
        }
        Reader &operator>>(char *str)
        {
            int len = 0;
            char c = getchar();
            while (c == ' ' || c == '\n')
            {
                c = getchar();
            }
            while (c != ' ' && c != '\n' && c != '\r')
            { // \r\n in windows
                str[len++] = c;
                c = getchar();
            }
            str[len] = '\0';
            return *this;
        }
        Reader &operator>>(GJ &x)
        {
            string str = "";
            char c = getchar();
            while (c == ' ' || c == '\n')
            {
                c = getchar();
            }
            while (c != ' ' && c != '\n' && c != '\r')
            { // \r\n in windows
                str += c;
                c = getchar();
            }
            //cout << str.c_str();
            x = str.c_str();
            return *this;
        }
        Reader() {}
    } cin;
    const char endl = '\n';
    struct Writer
    {
        Writer &operator<<(Doublee op)
        {
            static int n = pow(10, op.k);
            if (op.x == 0)
            {
                putchar('0'), putchar('.');
                for (int i = 1; i <= op.k; ++i)
                    putchar('0');
                return *this;
            }
            if (op.x < 0)
                putchar('-'), op.x = -op.x;
            long long y = (long long)(op.x * n) % n;
            op.x = (long long)op.x;
            cout << op.x;
            putchar('.');
            int bit[10], p = 0, i;
            for (; p < op.k; y /= 10)
                bit[++p] = y % 10;
            for (i = p; i > 0; i--)
                putchar(bit[i] + 48);
            return *this;
        }
        template <typename T>
        Writer &operator<<(T x)
        {
            if (x == 0)
            {
                putchar('0');
                return *this;
            }
            if (x < 0)
            {
                putchar('-');
                x = -x;
            }
            static int sta[111];
            int top = 0;
            while (x)
            {
                sta[++top] = x % 10;
                x /= 10;
            }
            while (top)
            {
                putchar(sta[top] + '0');
                --top;
            }
            return *this;
        }
        Writer &operator<<(char c)
        {
            putchar(c);
            return *this;
        }
        Writer &operator<<(char *str)
        {
            int cur = 0;
            while (str[cur])
                putchar(str[cur++]);
            return *this;
        }
        Writer &operator<<(const char *str)
        {
            int cur = 0;
            while (str[cur])
                putchar(str[cur++]);
            return *this;
        }
        Writer &operator<<(const GJ &x)
        {
            string str = x.str();
            int cur = 0;
            while (str[cur])
                putchar(str[cur++]);
            return *this;
        }
        Writer() {}
    } cout;
} // namespace Fastio
#define cin Fastio ::cin
#define cout Fastio ::cout
#define endl Fastio ::endl

/* --------------- fast io --------------- */ // end
心怀凉月
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
FastIO——读入/输出优化
用炮弹打苍蝇
10-18 1069
1.基本读入优化 输入：使用getchar代替scanf对模式串进行处理，调用时为引用 输出：直接调用，输出后没有跟空格或换行，需要手动添加putchar void read(int &x) { int f=1;x=0; char s=getchar(); while(s<'0'||s>'9') { if(s=='-')f=-1;...
C++ Fast IO 快读快输
Ryan_Right的博客
10-11 2978
没啥，就贴个板子。 自从我们开始学 OI 以来，我们就接触了 IO。在 zsjz，老师会说： 大家读入数字都用这个： cin>>n; 输出数字都有这个： cout<<n; 在 zsyz，老师会说： 大家读入数字都用这个： scanf("%d",&n); 输出数字都用这个： printf("%d",n); 效率上，肯定是后面的快，但是前面的如果只加上这一句，就可以和后面达到同样的效果： ios::sync_with_stdio(false); 但有些时候，两个都不行，
FastIo接口介绍
ShawnHoo的专栏
11-14 2973
由于你的驱动将要绑定到文件系统驱动的上边，文件系统除了处理正常的IRP 之外，还要处理所谓的FastIo.FastIo是Cache Manager 调用所引发的一种没有irp 的请求。换句话说，除了正常的Dispatch Functions 之外，你还得为DriverObject 撰写另一组Fast Io Functions.这组函数的指针在driver->FastIoDispatch.首先需
标题：掌握未来输入输出：探索高效能的C++快进IO库——fast_io
最新发布
gitblog_00065的博客
05-20 383
标题：掌握未来输入输出：探索高效能的C++快进IO库——fast_io 项目地址:https://gitcode.com/cppfastio/fast_io 在C++编程中，我们经常遇到性能瓶颈，尤其是在处理大量数据的输入和输出时。为此，一个名为fast_io的C++20库应运而生，它的目标是提供超乎想象的速度，并且替代传统的<iostream>和<cstdio>库。这是一...
手动实现cin与cout（程序设计，结构体FastIO的高效快读快写，保姆级教学）
jkkjkkjkkjkkj的博客
12-10 173
程序设计FastIO
Fast I/O和IRP_笔记
有趣的人生 一半是山川湖海 一半是初心情怀
08-13 1793
1. IRP and Fast I/O http://excel.fit.vutbr.cz/submissions/2019/019/19_poster.pdf 2.Minifilter 拦截FileMapping IO事件 https://blog.csdn.net/zj510/article/details/85059638#FileMapping_17 3 文件过滤 http...
【Fast IO】Fast IO 的探索及模板，竞赛专用。
x_mn的博客
08-14 1185
竞赛专用~~~ 通过测试一千万个数据的读入，来判断何种方法最快。每种测试结果都有时间附上。 首先生成一千万个随机数 #include<bits/stdc++.h> using namespace std; int main() { freopen("Date.txt","w",stdout); srand((unsigned)time(NULL)); for(int...
FastIo_ifsddk_fastio_ORS_
10-03
《IFSDDK中的FastIo与ORS机制详解》 在IT领域，文件系统驱动开发是一项至关重要的任务，它涉及操作系统与硬件设备之间的交互，确保数据的高效读写。IFSDDK（Installable File System Driver Development Kit）是...
FastIO.h——C++快读快写模板库
11-30
C++快读快写模板库（暂不支持实数、复数类型），适用于对输入输出速度要求高的场景。
FastIO:快速访问 Atmel 8 位 AVR MCU
06-08
快速IO 快速访问 Atmel 8 位 AVR MCU 在许多情况下，该库允许非常快速地访问 MCU 引脚和端口，使用单个指令来读/写或修改引脚或端口。依赖关系对 Arduino 环境绝对没有依赖性，这些文件可以在 Arduino IDE 之外使用...
IRPMon：该工具的目标是监视所选设备对象或内核驱动程序收到的请求。 该工具与IrpTracker十分相似，但具有一些增强功能。 它支持Windows的64位版本（不使用内联挂钩，仅执行对驱动程序对象结构的修饰），并监视IRP，FastIo，AddDevice，DriverUnload和StartIo请求
02-06
它的核心功能在于提供对IRP（I/O请求包）、FastIo、AddDevice、DriverUnload以及StartIo请求的深入洞察，这对于驱动程序开发、调试和系统分析至关重要。 1. **IRP（I/O请求包）**：IRP是Windows内核模式I/O系统的...
NXP2148的FASTIO驱动程序
05-20
FASTIO（Fast Input/Output）是NXP2148中的一个关键特性，它提供了一种高速、低延迟的接口，用于访问芯片上的GPIO（General Purpose Input/Output）引脚和其他外设。这个驱动程序是为了优化对这些硬件资源的访问速度...
Fast I/O
coding life
12-16 1918
文件过滤驱动 fast/io
FastIo
多媒体编程、网络编程、系统编程、网络安全编程、驱动编程
04-16 1758
由于你的驱动将要绑定到文件系统驱动的上边，文件系统除了处理正常的IRP 之外，还要处理所谓的FastIo.FastIo是Cache Manager 调用所引发的一种没有irp 的请求。换句话说，除了正常的Dispatch Functions 之外，你还得为DriverObject 撰写另一组Fast Io Functions.这组函数的指针在driver->FastIoDispatch. 首
BSOD原因 — FastIO
10-28 1075
      当阅读过滤驱动代码自己实践时，我想法是绑定完卷设备后，把所有的IRP都原封不动向下发，只是在passthru中打印个信息，表示经过了我的驱动，想看下效果。      用Device Tree查看，已成功绑定了D盘这个分区。用Dbgview查看，也能查看到输出信息。但是，绑定的D盘中，除了txt文件外，无法打开文件或运行程序，无法查看文件信息（创建日期，大小等），当一进行上述操作时，就B
C++之 Fast I/O
TSWorld
12-12 755
方法一： // TSWorld #include <bits/stdc++.h> int main() { ios::sync_with_stdio(false); cin.tie(NULL); cout.tie(NULL); return 0; } 方法二： // TSWorld #include <iostream> #include <cstdlib> #include <cstring> #include <cstdio> #in
fast-IO
weixin_30294021的博客
04-12 386
代码： 1 int Scan() //输入外挂 2 { 3 int res=0,ch,flag=0; 4 if((ch=getchar())=='-') 5 flag=1; 6 else if(ch>='0'&&ch<='9') 7 res=ch-'0'; 8 ...
Fast I/O C++ 快速输入/输出
TieWay59的博客
07-29 2288
index > Misc > Fast I/O 基本习惯 尽量printf /scanf 用cin /cout 的时候记得关同步 ios::sync_with_stdio(false); cin.tie(nullptr); 关同步的cin /cout 不要和printf /scanf混用。 注意endl自带了fflush，输出较慢。 虽然不一定很...
fastio c++
11-26
FastIO是一种用于加速输入输出操作的技术，在C语言中也有相关的实现。 在C语言中，标准的输入输出函数是以字节为单位进行操作的，每次调用这些函数都会引起系统调用，导致一定的时间开销。而FastIO则是利用缓冲区来...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值