1 标准IO

linux下一切皆文件！      

标准IO （基于有缓存的IO）eg:printf  fgetc  fputc

文件IO （基于无缓存的IO）eg:write   read

 

linux文件类型：

b/block　:块设备文件

c/character:字符设备文件

d/directory:目录文件

-:普通文件

l/link:链接文件（软连接、符号链接）

s/socket:套接字文件

p/pipe:管道文件

===================================================================

setvbuf.c

#include <stdio.h>

int main(void)
{
    char buf[4096];
//    char buf[1024];

    setvbuf(stdout, buf, _IOFBF, sizeof(buf));
//    setvbuf(stdout, NULL, _IONBF, 0);
    printf("hello world!");

//    while (1);

    return 0;
}
/*
 *int setvbuf(FILE *stream, char *buf, int mode, size_t size);
 *功能：改变缓存的类型，用buf指向的空间来代替现有的缓存区
 *参数：文件流指针/新缓存区首地址
         /缓存模式：1:_IOFBF（全缓存）
                   2:_IOLBF（行缓存）
                   3:_IONBF（不换存）
        /新缓存区的大小
 *返回值：成功返回0；失败返回非0
 * */

fgetc.c

#include <stdio.h>
int main(void)
{
    FILE *fp = NULL;
    char ret = 0;
    if(NULL==(fp = fopen("file_fgetc.txt","r"))) {
        perror("fail to fopen!");
        return -1;
    }
//从文件中读取数据并打印
    while((ret = fgetc(fp))!=EOF) {
        //printf("ret = %c\n",ret);
        printf("%c ",ret);
    }
    fclose(fp);
    return 0;
}
/*
 *int fgetc(FILE *stream);      ==>getchar()=fgetc(stdin);
 *功能：从流中读取一个字符
 *返回值：成功返回读取到的字符的ASCII码值；失败返回EOF/读到文件末尾返回EOF
 *
 *FILE *fopen(const char *path, const char *mode);
 *功能：打开一个文件，获取一个文件流指针
 *参数：打开文件的路径/打开模式：
     1.r： 不存在则报错；存在则只读打开
     2.r+：不存在则报错；存在则读写打开
    3.w:  不存在则创建；存在则清空只写打开
    4.w+: 不存在则创建；存在则清空写读打开
    5.a:  不存在则创建；存在则追加只写打开
    6.a+: 不存在则创建；存在则追加写读打开
 *返回值：成功返回文件流指针；失败返回NULL
 *
 * */

file_fgetc.c

 hello world!abc 

fputc.c

#include <stdio.h>
int main(void)
{
    FILE *fp = NULL;
    char ret = 0;
    if(NULL==(fp = fopen("file_fputc.txt","w"))) {
        perror("fail to fopen!");
        return -1;
    }
    fputc('I',fp);
    fputc('l',fp);
    fputc('o',fp);
    fputc('v',fp);
    fputc('e',fp);
    fputc('y',fp);
    fputc('o',fp);
    fputc('u',fp);

    fclose(fp);
    return 0;
}
/*
 *int fputc(int c, FILE *stream);      ==> putchar()=fputc(stdout);
 *功能：向流中写入一个字符
 *参数：字符的ASCII码值/文件流指针
 *返回值：成功返回写入字符的ASCII码值；失败返回EOF
 *
 * */

file_fputc.c

 Iloveyou 

=====================================================================

fputs.c

#include <stdio.h>
int main(void)
{
#if 0
    puts("hello world!");//在输入字符串末尾加\n
    puts("i love you!");
#endif
#if 1
    fputs("hello word!",stdout);//直接将字符串输出不加\n
    fputs("i love you!",stdout);
#endif

　　 FILE *fp = NULL;
　　 if(NULL == (fp = fopen("file_fputs.c","w"))) {
　　　　　　perror("fail to fopen!\n");
　　 }
　　　　fputs("hello gaga!",fp);
　　　　fputs("33333333333",fp);

    return 0;
}

/*
 *int fputs(const char *s, FILE *stream);   ==> fputs(s, stdout) = puts(s);//等价关系
 *功能：向流中写入一串字符                异同：fputs:直接将字符串输出，不加'\n'或'\0'        
 *参数：字符串首地址/文件流指针                puts:在输入字符串末尾加'\n'
 *返回值：成功返回非负数；失败返回EOF
 *
 * */

fgets.c

#include <stdio.h>
int main(void)
{
    FILE *fp = NULL;
    char ret = 0;
    if(NULL==(fp = fopen("file_fgets.txt","r"))) {
        perror("fail to fopen!");
        return -1;
    }
    char buff[1024]={0};
    fgets(buff,sizeof(buff),fp);//从文件中读取数据到 buff
                                //fgets自带\n;不会去掉从终端读取的\n
        printf("%s\n",buff);
    fgets(buff,sizeof(buff),fp);//从文件中读取数据到 buff
        printf("%s\n",buff);
    fgets(buff,sizeof(buff),fp);//从文件中读取数据到 buff
        printf("%s\n",buff);

    fclose(fp);
    return 0;
}

/*
 *char *fgets(char *s, int size, FILE *stream);
 *功能：从流中读取一字符串，最少读1个，最多读size个字节，遇到EOF或者'\n'停止读取，每次读取字符串末尾要加'\0'
 *参数：读取到数据存放新空间的首地址/数据存放空间的大小/文件流指针
 *返回值：成功返回存放空间的首地址；失败或者读到文件末尾返回NULL
 *
 *gets和fgets异同：
 *1.gets不限定从终端读取字符的个数，如果超过最大保存字符个数，数据会溢出，容易产生漏洞/会去掉。。。下
 *2.fgets限定从终端读取字符的个数，不会产生溢出错误/不会去掉从终端读取的'\n'字符
 *
 *
 * */

file_fgets.txt

 hello world! 2 i love you! 

gets.c

#include <stdio.h>
int main(void)
{
    char buff[1024]={0};
    gets(buff);//获取 buff
                //会去掉从终端读取的\n
//    fgets(buff,sizeof(buff),stdin);//与上等价
        printf("%s\n",buff);

    return 0;
}

/*
 *
 * */

fwrite.c

#include "head.h"
int main(void)
{
    FILE*fp = NULL;
    struct student s1 = {"gemeng",100421104,'m',24};
    struct student s2 = {"heheda",100421105,'f',23};
    if(NULL == (fp = fopen("info.txt","w"))) {
        perror("fail to fopen!");
        return -1;
    }
    fwrite(&s1,sizeof(struct student),1,fp);//从指定地址/buff 读取数据到fp
    fwrite(&s2,sizeof(struct student),1,fp);

    fclose(fp);
    return 0;
}
/*
 *size_t fwrite(const void *ptr, size_t size, size_t nmemb,FILE *stream);
 *功能：向流中写入nmemb个数据对象，每个对象大小为size,对象以前存放地址为ptr
 *返回值：成功返回实际写入的数据对象的个数；失败返回0
 *
 * */

fread.c

#include "head.h"
int main(void)
{
    FILE*fp = NULL;
    struct student a1;
    struct student a2;
    if(NULL == (fp = fopen("info.txt","r"))) {
        perror("fail to fopen!");
        return -1;
    }
    int ret = 0;
    ret = fread(&a1,sizeof(struct student),1,fp);//从fp读取数据到指定地址/buff
    printf("ret:%d\n",ret);
    printf("name:%s\n",a1.name);
    printf("num:%d\n",a1.num);
    printf("sex:%c\n",a1.sex);
    printf("age:%d\n",a1.age);
    ret = fread(&a2,sizeof(struct student),1,fp);
    printf("ret:%d\n",ret);
    printf("name:%s\n",a2.name);
    printf("num:%d\n",a2.num);
    printf("sex:%c\n",a2.sex);
    printf("age:%d\n",a2.age);

    fclose(fp);
    return 0;
}
/*
 * size_t fread(void *ptr, size_t size, size_t nmemb, FILE *stream);
 * 功能：从流中读取nmemb个对象，每个对象size大小，存放到ptr指向的空间地址
 * 返回值：成功返回读取对象的个数；失败或者读到文件末尾返回0
 *
 * */

copy_1.c

#include <stdio.h>
int main(char argc,const char *argv[])
{
    if(argc != 3) {
        fprintf(stderr,"Usage:./a.out 源文件 目的文件\n");
            return -1;
    }
    FILE *fsrc = NULL;
    FILE *fdst = NULL;
    fsrc = fopen(argv[1],"r");
    fdst = fopen(argv[2],"w");
    if((fsrc == NULL)|(fdst == NULL)) {
        perror("fail to fopen!");
        return -1;
    }
    char ret = 0;
    /*利用fgetc和fputc来实现拷贝功能*/
    while((ret = fgetc(fsrc)) != EOF) {
        fputc(ret,fdst);
    }

    fclose(fsrc);
    fclose(fdst);

    return 0;
}

copy_2.c

#include <stdio.h>
int main(char argc,const char *argv[])
{
    if(argc != 3) {
        fprintf(stderr,"Usage:./a.out 源文件 目的文件\n");
            return -1;
    }
    FILE *fsrc = NULL;
    FILE *fdst = NULL;
    fsrc = fopen(argv[1],"r");
    fdst = fopen(argv[2],"w");
    if((fsrc == NULL)|(fdst == NULL)) {
        perror("fail to fopen!");
        return -1;
    }
//    char ret = 0;
    char buff[1024] = {0};
    /*利用fgets和fputs来实现拷贝功能*/
    while((NULL != fgets(buff,sizeof(buff),fsrc))) {
        fputs(buff,fdst);
    }

    fclose(fsrc);
    fclose(fdst);

    return 0;
}

copy_3.c

#include <stdio.h>
int main(char argc,const char *argv[])
{
    if(argc != 3) {
        fprintf(stderr,"Usage:./a.out 源文件 目的文件\n");
            return -1;
    }
    FILE *fsrc = NULL;
    FILE *fdst = NULL;
    fsrc = fopen(argv[1],"r");
    fdst = fopen(argv[2],"w");
    if((NULL == fsrc)|(NULL == fdst)) {
        perror("fail to fopen!");
        return -1;
    }
    int ret = 0;
    char buff[1024] = {0};
    /*利用fread和fwrite来实现拷贝功能*/
    while((ret = fread(buff,sizeof(char),1024,fsrc)) != 0) {
        fwrite(buff,sizeof(char),ret,fdst);
    }

    fclose(fsrc);
    fclose(fdst);

    return 0;
}