fread读入挂and普通读入挂and浮点数读入挂

fread读入挂

版本一

namespace fastIO {
  #define BUF_SIZE 100000
  //fread -> read
  bool IOerror = 0;
  inline char nc() {
    static char buf[BUF_SIZE], *p1 = buf + BUF_SIZE, *pend = buf + BUF_SIZE;
    if(p1 == pend) {
      p1 = buf;
      pend = buf + fread(buf, 1, BUF_SIZE, stdin);
      if(pend == p1){
        IOerror = 1;
        return -1;
      }
    }
    return *p1++;
  }
  inline bool blank(char ch) {
    return ch == ' ' || ch == '\n' || ch == '\r' || ch == '\t';
  }
  template<typename T>
  inline void read(T &x) {
    char ch;
    while(blank(ch = nc()));
    if(IOerror)
      return;
    for(x = ch - '0'; (ch = nc()) >= '0' && ch <= '9'; x = x * 10 + ch - '0');
  }
  #undef BUF_SIZE
};

using namespace fastIO;

版本二

struct FastIO {
    static const int S = 1e7;
    int wpos;
    char wbuf[S];
    FastIO() : wpos(0) {}
    inline int xchar() {
        static char buf[S];
        static int len = 0, pos = 0;
        if (pos == len)
            pos = 0, len = fread(buf, 1, S, stdin);
        if (pos == len) exit(0);
        return buf[pos++];
    }
    inline int xuint() {
        int c = xchar(), x = 0;
        while (c <= 32) c = xchar();
        for (; '0' <= c && c <= '9'; c = xchar()) x = x * 10 + c - '0';
        return x;
    }
    inline int xint() {
        int s = 1, c = xchar(), x = 0;
        while (c <= 32) c = xchar();
        if (c == '-') s = -1, c = xchar();
        for (; '0' <= c && c <= '9'; c = xchar()) x = x * 10 + c - '0';
        return x * s;
    }
    inline void xstring(char *s) {
        int c = xchar();
        while (c <= 32) c = xchar();
        for (; c > 32; c = xchar()) * s++ = c;
        *s = 0;
    }
    inline void wchar(int x) {
        if (wpos == S) fwrite(wbuf, 1, S, stdout), wpos = 0;
        wbuf[wpos++] = x;
    }
    inline void wint(LL x) {
        if (x < 0) wchar('-'), x = -x;
        char s[24];
        int n = 0;
        while (x || !n) s[n++] = '0' + x % 10, x /= 10;
        while (n--) wchar(s[n]);
        wchar('\n');
    }
    inline void wstring(const char *s) {
        while (*s) wchar(*s++);
    }
    ~FastIO() {
        if (wpos) fwrite(wbuf, 1, wpos, stdout), wpos = 0;
    }
} io;

版本三

inline char nc(){
    static char buf[100000],*p1=buf,*p2=buf;
    return p1==p2&&(p2=(p1=buf)+fread(buf,1,100000,stdin),p1==p2)?EOF:*p1++;
}
inline int _read(){
    char ch=nc();int sum=0;
    while(!(ch>='0'&&ch<='9'))ch=nc();
    while(ch>='0'&&ch<='9')sum=sum*10+ch-48,ch=nc();
    return sum;
}

版本四

#include<cstdio>
#include<iostream>
using namespace std;
const int maxx=40000008;
char Input[maxx+5],*ipos;
#define read() (strtol(ipos,&ipos,10))

int main() {
    fread(Input,maxx,1,stdin);ipos=Input;
    int n=read();

    //Do something......
    return 0;
}

版本五

const int STRSIZE=int(4e7);
char in1[STRSIZE];
char *in=in1, *tempend;
void Input() {
    tempend=in+STRSIZE;
    fread(in,1,STRSIZE,stdin);
}
inline void scan(int &x) {
    char c=*(in++);
    while(!(c>='0' && c<='9')) c=*(in++);
    x=c-'0';
    c=*(in++);
    while(c>='0' && c<='9') {
        x=x*10+c-'0';
        c=*(in++);
    }
}

版本六

const int BufferSize=1<<16;
char buffer[BufferSize],*head,*tail;
inline char Getchar() {
    if(head==tail) {
        int l=fread(buffer,1,BufferSize,stdin);
        tail=(head=buffer)+l;
    }
    return *head++;
}
inline int read() {
    int x=0,f=1;char c=Getchar();
    for(;!isdigit(c);c=Getchar()) if(c=='-') f=-1;
    for(;isdigit(c);c=Getchar()) x=x*10+c-'0';
    return x*f;
}
inline void write(int x){
    if(x>=10)write(x/10);
    putchar(x%10+'0');
}

版本七

namespace IO {
    const int MX = 4e7; //1e7占用内存11000kb
    char buf[MX]; int c, sz;
    void begin() {
        c = 0;
        sz = fread(buf, 1, MX, stdin);
    }
    inline bool read(int &t) {
        while(c < sz && buf[c] != '-' && (buf[c] < '0' || buf[c] > '9')) c++;
        if(c >= sz) return false;
        bool flag = 0; if(buf[c] == '-') flag = 1, c++;
        for(t = 0; c < sz && '0' <= buf[c] && buf[c] <= '9'; c++) t = t * 10 + buf[c] - '0';
        if(flag) t = -t;
        return true;
    }
}

版本八

struct FastIO {
    static const int S = 100 << 1;
    int wpos;
    char wbuf[S];
    FastIO() : wpos(0) {}
    inline int xchar() {
        static char buf[S];
        static int len = 0, pos = 0;
        if (pos == len) {
            pos = 0;
            len = (int)fread(buf, 1, S, stdin);
        }
        if (pos == len) {
            return -1;
        }
        return buf[pos++];
    }
    inline int xint() {
        int s = 1, c = xchar(), x = 0;
        while (c <= 32) {
            c = xchar();
        }
        if (c == '-') {
            s = -1;
            c = xchar();
        }
        for (; '0' <= c && c <= '9'; c = xchar()) {
            x = x * 10 + c - '0';
        }
        return x * s;
    }
    ~FastIO() {
        if (wpos) {
            fwrite(wbuf, 1, wpos, stdout);
            wpos = 0;
        }
    }
} io;

版本九:

namespace fastio{
  int ptr, ye, Siz;
  char temp[25], str[8333667], out[8333669];
  void io_init(){
    ptr = 0, ye = 0;
    Siz = fread(str, 1, 8333667, stdin);
  }
  inline int read(){
    int i, j, val = 0, fla = 1;
    while (ptr<Siz&&(str[ptr] < 48 || str[ptr] > 57)) ptr++;
    if(ptr>=Siz)return -1;
    while (str[ptr] > 47 && str[ptr] < 58) fla = 0,val = (val * 10) + (str[ptr++] - 48);
    if(fla)return -1;
    return val;
  }
  inline void convert(long long x,bool flag){
    int i, d = 0;
    for (; ;){
      temp[++d] = (x % 10) + 48;
      x /= 10;
      if (!x) break;
    }
    for (i = d; i; i--) out[ye++] = temp[i];
    out[ye++] = ' ';
    if(flag) out[ye-1] = 10;
  }
  inline void io_print(){
    fwrite(out, 1, ye, stdout);
  }
}
using namespace fastio;

fread()函数和fwrite()函数:(可以用来实现对数据块的操作)

// 读取文件块数据
size_t fread(void *buffer, size_t size, size_t count, FILE *file);

// 写入文件块数据
size_t fwrite(const void *buffer, size_t size, size_t count, FILE *file);

fread参数说明:buffer是读取数据后存放地址,size是的块长度,count是块的数量,实际读取长度为sizecount,返回值为块成功读取块的count数量。
fwrite参数说明:buffer是写入数据后存放地址,size是的块长度,count是块的数量,实际读取长度为size
count,返回值为块成功写入快的count数量。

普通读入挂

版本一:

int read(){
    int sum=0;char ch=getchar();
    while(!(ch>='0'&&ch<='9'))ch=getchar();
    while(ch>='0'&&ch<='9')sum=sum*10+ch-48,ch=getchar();
    return sum;
}

strtok和sscanf结合输入

/*
 *  空格作为分隔输入,读取一行的整数
 */
gets(buf);

int v;
char *p = strtok(but, " ");
while (p){
    sscanf(p, "%d", &v);
    p = strtok(NULL," ");
}

浮点数

inline bool scan_lf(double &num)  {
        char in;double Dec=0.1;
        bool IsN=false,IsD=false;
        in=getchar();
        if(in==EOF) return false;
        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;
                return true;
        }else{
                while(in=getchar(),in>='0'&&in<='9'){
                        num+=Dec*(in-'0');Dec*=0.1;
                }
        }
        if(IsN) num=-num;
        return true;
}

qsc的读入挂:传送门

原文地址:https://www.cnblogs.com/Cwolf9/p/9513186.html

时间: 2024-10-13 01:29:00

fread读入挂and普通读入挂and浮点数读入挂的相关文章

【BZOJ4247】挂饰

Description JOI君有N个装在手机上的挂饰,编号为1-N. JOI君可以将其中的一些装在手机上. JOI君的挂饰有一些与众不同--其中的一些挂饰附有可以挂其他挂件的挂钩.每个挂件要么直接挂在手机上,要么挂在其他挂件的挂钩上.直接挂在手机上的挂件最多有1个. 此外,每个挂件有一个安装时会获得的喜悦值,用一个整数来表示.如果JOI君很讨厌某个挂饰,那么这个挂饰的喜悦值就是一个负数. JOI君想要最大化所有挂饰的喜悦值之和.注意不必要将所有的挂钩都挂上挂饰,而且一个都不挂也是可以的. In

[bzoj4247][挂饰] (动规+排序)

Description JOI君有N个装在手机上的挂饰,编号为1...N. JOI君可以将其中的一些装在手机上. JOI君的挂饰有一些与众不同——其中的一些挂饰附有可以挂其他挂件的挂钩.每个挂件要么直接挂在手机上,要么挂在其他挂件的挂钩上.直接挂在手机上的挂件最多有1个. 此外,每个挂件有一个安装时会获得的喜悦值,用一个整数来表示.如果JOI君很讨厌某个挂饰,那么这个挂饰的喜悦值就是一个负数. JOI君想要最大化所有挂饰的喜悦值之和.注意不必要将所有的挂钩都挂上挂饰,而且一个都不挂也是可以的.

如何轻松防范DEDE挂马

曾经有许朋友的DEDE后台程序很容易被挂马,当然每个人都是通过一点一点积累经验,从被挂到能轻松防范,这需要一个逐渐积累的过程,任何事情都不是一蹴而就的,所以我们只要研究了方法就不会被挂马. 下面就来谈一谈具体的方法: 精简设置篇: 不需要的功能统统删除.比如不需要会员就将member文件夹删除.删除多余组件是避免被hack注射的最佳办法.将每个目录添加空的index.html,防止目录被访问. 织梦可删除目录列表:member会员功能 special专题功能 install安装程序(必删) co

常用读入\输出优化

本文主要讲述常用的2种读入优化方法. 输出优化很少使用,在此简单提一下:也就是把输出的东西先放进字符串,再一次性puts\printf出去.提升不大,不常用. 首先当然需要先知道,scanf/printf比cin/cout快不少. 读入优化: getchar 使用getchar一个一个读入字符,转化成数字.比scanf快一些. inline int read() { int f=1,x=0;//f是正负的标识 char ch; do { ch=getchar(); if(ch=='-') f=-

怎样进行网站被挂马检测?工具有哪些呢?

使用搜索引擎搜索"网站挂马检测"我们可以看到有许多的网站挂马检测工具及网站被挂马检测工具平台.我们来看看常用的网站被挂马检测工具及在线网站被挂马检测工具平台都有那些? 360网站安全检测平台(http://webscan.360.cn): 可以免费在线检测网站.网页木马.网站后门程序.网站漏洞等.网站在线被挂马检测,不需要网站验证,但如果想看到网站安全详情,就需要网站验证. 百度云观测(http://ce.baidu.com): 可以检测网站运行状况.网站安全性.网站访问速度.网站SE

磁盘管理,磁盘挂在mount,挂载光盘镜像文件,挂在U盘,umount 卸载命令, dd

1 mount 命令格式: mount[-t vfstype] -o options device dir 其中: *-t vfstype 指定文件系统的类型,通常不必指定.mount会自动选择正确的类型.常 用类型有: 光盘或光盘镜像:iso9660 DOSfat16文件系统:msdos Windows9x fat32文件系统:vfat WindowsNT ntfs文件系统:ntfs MountWindows文件网络共享:smbfs UNIX(LINUX)文件网络共享:nfs *-o opti

为什么operator&gt;&gt;(istream&amp;, string&amp;)能够安全地读入长度未知的字符串?

一般而言,实现"读入用户输入的字符串",程序中自然不能对用户输入的长度有所限定.这在C++中很容易实现,而在C中确没那么容易. 这一疑问,我在刚学C++的时候也在脑中闪现过:不过很快将它抛在脑后了.直到最近,我在百度知道上讨论一个单词统计问题(链接)时,才重新想起.于是,翻出gcc 4.6.1的代码,浏览了一番. 首先,明确这里探讨的场景--从标准输入(或字符模式打开的文件)中读取一个字符串(换行.空格.tab间隔均可).用C++实现这一功能有两种选择--使用C标准库和使用C++标准库

c# sleep 例子-线程挂起

using System; using System.Threading; public class arr { public static void Main() { //int[] arr; //arr = new int[5]; int luzi; for(luzi=1;luzi<10000;luzi++) { Console.WriteLine("第"+luzi+"行"); if (luzi==5000) { Thread.Sleep(10000);

Windows DIB文件操作详解-1.DIB的读入、保存和显示

DIB(设备无关位图)是存储在磁盘上的位图文件,可以从磁盘读到内存中或从内存保存到磁盘上,它的磁盘文件结构是标准化的,在Linux.Unix及Windows上都可以以同样效果显示.位图是最接近硬件的图像格式,Windows显示的核心是位图,它的SDK API专门提供了一组用于操作DIB文件的函数.但是由于这样或那样的原因,高效合理的使用这些DIB API是需要了解不少历史和使用背景的,在这里我抽茧剥丝介绍和演示DIB的使用,相信对你更好的使用DIB文件有帮助,由于DIB函数比较多,这里分为三部分