精华内容
下载资源
问答
  • Linux文件操作高频使用命令

    万次阅读 多人点赞 2019-08-28 16:47:38
    新建操作:1.查看操作2.删除操作3.复制操作4.移动操作:5.重命名操作:6.解压压缩操作 0.新建操作: mkdir abc #新建一个文件夹 touch abc.sh #新建一个文件 1.查看操作 查看目录: ll #显示目录文件...

    0.新建操作:

    mkdir abc #新建一个文件夹
    touch abc.sh #新建一个文件
    echo "abc" > test.txt #新建一个文件,并将abc写入。这里用到了重定向符
    

    1.查看操作

    • 查看目录:
    ll #显示目录文件详细信息
    du -h 文件/目录  #查看大小
    pwd #显示路径
    
    • 查看文件内容:

      cat|head|tail命令

    cat abc.txt #查看abc的内容
    head -5 abc.txt #查看abc前5行内容。默认是10行
    
    tail [选项] 文件名
    各选项的含义如下:
    +num:从第num行以后开始显示
    -num:从距文件尾num行处开始显示。如果省略num参数,系统默认值为10.
    -f: 循环读取,例如查看服务器日志时,可以实时观察
    #filename 文件里的最尾部的内容显示在屏幕上,并且不断刷新。
    tail -f filename 
    #查看最后20行
    tail -f filename
    
    
    
    

    ​ more命令:

    more命令一次显示一屏信息,若信息未显示完屏幕底部将出现“-More-(xx%)”。
    
    此时按Space键,可显示下一屏内容;
    
    按“回车”键,显示下一行内容;
    
    按B键,显示上一屏;
    
    按Q键,可退出more命令。
    

    ​ less命令:和more命令类似,但是比more命令更强大。在很多时候,必须使用less,比如管道。例如:

    ll /etc | less
    
    • 查看状态或文件类型:
      stat 命令:
      查看文件的详细信息,比如创建修改时间,大小等
    [root@localhost zx]# stat index.html 
      文件:"index.html"
      大小:29006     	块:64         IO 块:4096   普通文件
    设备:fd00h/64768d	Inode:17589607    硬链接:1
    权限:(0644/-rw-r--r--)  Uid:(    0/    root)   Gid:(    0/    root)
    环境:unconfined_u:object_r:home_root_t:s0
    最近访问:2019-09-02 21:47:41.824053666 +0800
    最近更改:2019-09-02 21:44:33.588587500 +0800
    最近改动:2019-09-02 21:44:33.588587500 +0800
    创建时间:-
    
    

    file命令: Linux中后缀并没有实际约束意义。

    file test.txt #查看test.txt的文件类型
    

    du 命令:
    选项:-h 以合适的单位显示(会根据文件的大小自动选择kb或M等单位)

    [root@localhost zx]# du -h index.html 
    32K	index.html
    

    2.删除操作

    rm -f  aa.txt #强制删除aa.txt
    rm -rf fileDir #强制删除fileDir文件夹和里边的所有文件
    

    3.复制操作

    • 同一机器的复制:
    cp:复制文件或目录
    语法:
    cp [options] source dest
    
    -a:此选项通常在复制目录时使用,它保留链接、文件属性,并复制目录下的所有内容。其作用等于dpR参数组合。
    -d:复制时保留链接。这里所说的链接相当于Windows系统中的快捷方式。
    -f:覆盖已经存在的目标文件而不给出提示。
    -i:与-f选项相反,在覆盖目标文件之前给出提示,要求用户确认是否覆盖,回答"y"时目标文件将被覆盖。
    -p:除复制文件的内容外,还把修改时间和访问权限也复制到新文件中。
    -r:若给出的源文件是一个目录文件,此时将复制该目录下所有的子目录和文件。
    -l:不复制文件,只是生成链接文件。
    
    举例:
    #将../html/index.html 复制到当前目录
    cp ../html/index.html .    
    #将../html/ 目录下的文件及子目录复制到当前的tt目录下,如果tt不存在,会自动创建
    cp -r ../html/  tt/       
    #将文件file复制到目录/usr/men/tmp下,并改名为file1
    cp file /usr/men/tmp/file1  
        
    #如果dir2目录已存在,则需要使用
    cp -r dir1/. dir2
    #如果这时使用cp -r dir1 dir2,则也会将dir1目录复制到dir2中,明显不符合要求。
    ps:dir1、dir2改成对应的目录路径即可。
    
    • 远程复制
    #将当前目录下的test.txt复制到远程111.12机器的/zx目录下
    scp test.txt root@192.168.111.12:/zx
    
    #将test.txt复制到远程用户的根目录,并命名为textA.txt
    scp test.txt root@192.168.111.12:testA.txt
    
    #也可以不指定用户,在后续提示中再输入,如下:
    scp test.txt 192.168.111.12:/zx
    
    #从远程复制到本地: -r用于递归整个目录
    scp -r remote_user@remote_ip:remote_folder local_path
    

    4.移动操作:

    移动操作可以理解成复制文件后,删除原文件。

    eg1:

    mv /zx/soft/* . #复制/zx/soft目录中的所有文件到当前目录
    mv a.txt ./test/a.txt  #复制当前目录a.txt到当前的test目录下。
    mv a.txt ./test/ -f  #移动到test目录,如果存在就覆盖
    mv /zx/soft/  /tmp/soft  #复制文件夹到/tmp/下,必须保证tmp是存在的文件夹
    

    5.重命名操作:

    重命名还是用的移动操作命令,比如:

    #将目录(文件)A重命名为B
    mv A B
    #将/a目录(文件)移动到/b下,并重命名为c。要保证b目录存在。
    mv /a /b/c
    #将当前test1目录移动到当前的test目录并命名为b
    mv ./test1 ./test/b 
    

    6.解压压缩操作

    tar
    -c: 建立压缩档案
    -x:解压
    -t:查看内容
    -r:向压缩归档文件末尾追加文件
    -u:更新原压缩包中的文件
    这五个是独立的命令,压缩解压都要用到其中一个,可以和别的命令连用但只能用其中一个。下面的参数是根据需要在压缩或解压档案时可选的。
    
    -z:有gzip属性的
    -j:有bz2属性的
    -Z:有compress属性的
    -v:显示所有过程
    -O:将文件解开到标准输出
    
    下面的参数-f是必须的
    -f: 使用档案名字,切记,这个参数是最后一个参数,后面只能接档案名。
    
    三、举例说明:
    tar -cf all.tar *.jpg
    这条命令是将所有.jpg的文件打成一个名为all.tar的包。-c是表示产生新的包,-f指定包的文件名。
    tar -tf all.tar
    这条命令是列出all.tar包中所有文件,-t是列出文件的意思
    tar -xf all.tar
    这条命令是解出all.tar包中所有文件,-x是解开的意思
    压缩
    tar –cvf jpg.tar *.jpg //将目录里所有jpg文件打包成jpg.tar
    eg2:
        tar -xzf nginx-1.14.0.tar.gz //解压到当前目录
        tar -zxf nginx-1.14.0.tar.gz -C /usr/local/nginx  #解压到对应目录
     eg3:
     	tar -zxvf nginx...tar.gz #解压并显示过程
     	
    注意:有些压缩程序提示命令找不到,需要进行安装,例如:
    yum install unzip
    或在ubuntu上:
    apt-get install unzip
    
    四、总结
    1、*.tar 用 tar –xvf 解压
    2、*.gz 用 gzip -d或者gunzip 解压
    3、*.tar.gz和*.tgz 用 tar –xzf 解压
    4、*.bz2 用 bzip2 -d或者用bunzip2 解压
    5、*.tar.bz2用tar –xjf 解压
    6、*.Z 用 uncompress 解压
    7、*.tar.Z 用tar –xZf 解压
    8、*.rar 用 unrar e解压
    9、*.zip 用 unzip 解压  
    
    解压的时候,有时候不想覆盖已经存在的文件,那么可以加上-n参数
    unzip -n test.zip
    unzip -n -d /temp test.zip
    只看一下zip压缩包中包含哪些文件,不进行解压缩
    unzip -l test.zip
    查看显示的文件列表还包含压缩比率
    unzip -v test.zip
    检查zip文件是否损坏
    unzip -t test.zip
    如果已有相同的文件存在,要求unzip命令覆盖原先的文件
    unzip -o test.zip -d /tmp/
    示例:
     eg1:  unzip mydata.zip -d mydatabak #解压到mydatabak目录
     eg2 :zip -r xxx.zip ./*  #压缩当前目录下的内容为一个xxx.zip
     eg3: zip xx.zip  a.txt b.txt c.txt #将abc三个文件压缩为xx.zip
    10. xz
    	这是两层压缩,外面是xz压缩方式,里层是tar压缩,所以可以分两步实现解压
    	$ xz -d node-v6.10.1-linux-x64.tar.xz
        $ tar -xvf node-v6.10.1-linux-x64.tar
    

    7.上传文件工具

    从本地windows上传一些文件到远程Linux服务器可以通过xshell的xftp也可以通过下面这个小工具lrzsz,使用更加方便。

    yum install lrzsz #安装工具
    
    常用命令:
    sz dist.zip #下载文件dist.zip到本地
    rz #会打开窗口,上传文件到远程服务器
    

    8.ln、file和touch命令

    • ln命令:名用于创建链接文件,包括硬链接(Hard Link)和符号链接(Symbolic Link) 。我们常用的是符号链接,也称软连接。软连接就类似windows里的快捷方式。

      示例:

      #在当前目录创建一个软连接,指向/etc/fastab,名称也是fastab
      ln -s /etc/fastab
      
      #在当前目录创建一个指向/boot/grub的软连接,命名为gb
      ln -s /boot/grub gb
      

      注意:删除软连接 正确方式是:

      rm -rf ./gb
      

      错误方式:

      rm -rf ./gb/
      

      这样会删除了原有grub下的内容。特别是针对系统文件的软连接,删除一定要慎重。

    • file命令 用于识别文件的类型

    Linux中文件后缀只是方便使用者识别,没有实质的约束作用。file命令可以查看文件的实质类型:

    file [-bcLz] 文件|目录
    

    选项说明:

    • 文件|目录:需要识别的文件或目录
    • -b: 显示识别结果时,不显示文件名
    • -c: 显示执行过程
    • -L: 直接显示符号链接文件指向的文件类型
    • -z: 尝试去解读压缩文件的内容

    示例: 可以看出,index.mp4本质是一个HTML而非一个mp4文件

    [root@VM_0_13_centos soft]# file index.mp4 
    index.mp4: HTML document, UTF-8 Unicode text, with very long lines
    
    • touch命令: 用于改变文件或目录的访问时间和修改时间。

      touch [-am] [-t<日期时间>] [目录|文件]
      

      如果指定目录文件不存在,则会直接创建一个空文件,所以touch也常用来创建一个空白文件

      #创建一个新文件aa.txt
      touch aa.txt
      

      选项说明:

      • -a: 只修改访问时间
      • -m : 只修改 修改时间
      • -t : 使用指定日期时间,而非系统时间 。例如要修改为2019年10月20日16:38分13秒。参数就是:‘20191020163813’

      示例:

      修改之前可以先查看文件的时间戳: 用stat 命令查看

      [root@VM_0_13_centos soft]# stat index.html 
        File: ‘index.html’
        Size: 17215     	Blocks: 40         IO Block: 4096   regular file
      Device: fd01h/64769d	Inode: 529352      Links: 1
      Access: (0644/-rw-r--r--)  Uid: (    0/    root)   Gid: (    0/    root)
      Access: 2019-10-23 15:15:37.280616254 +0800
      Modify: 2019-10-23 15:15:37.280616254 +0800
      Change: 2019-10-23 15:15:37.290616257 +0800
       Birth: -
      
      

      开始修改:将index.html文件的访问和修改时间修改成当前系统的时间。

      touch index.html
      

    9.查找操作命令:

    对于要用到的文件,目录等,经常有忘记的时候,所以查找命令就显得极为必要:

    • find: 查找文件或目录 (常用)

      语法如下:

      find [目录…] [-amin <分钟>] [-atime <24小时数>] [-cmin <分钟>] [-ctime<24小时数>][-empty][-exec<执行命令>][-fls<列表文件>][-follow]
          [-fstype <系统文件类型>] [-gid <组编号>] [-group <组名称>] [-nogroup] [-mmin <分钟>]  [-mtime
          <24小时数>] [-name <查找内容>] [-nogroup] [-nouser] [-perm <权限数值>] [-size <文件大小>] [-uid
          <用户编号>] [-user <用户名称>] [-nouser]
      
      
      

      几个常用选项说明:

      • -size <文件大小>:查找符合指定大小的文件。文件大小单位可以是“c”表示Byte;“k”表示KB。如配置为“100k”,find命令会查找文件大小正好100KB的文件;配置为“+100k”,find命令会查找文件大小大于100KB的文件;配置为“-100k”,find命令会查找文件大小小于100KB的文件。
      • -user<用户名称>:查找所有者是指定用户的文件或目录,也能以用户编号指定
      • -name <查找内容>:查找指定的内容,在查找内容中使用“*” 表示任意个字符;使用“?”表示任何一个字符
      • -mtime <24小时数>:查找在指定时间曾更改过内容的文件或目录,单位以24小时计算。如配置为2,find命令会查找刚好在48小时之前更改过内容的文件;配置为+2,find命令会查找超过在48小时之前更改过内容的文件;配置为-2,find命令会查找在48小时之内更改过内容的文件。
      • -mmin <分钟>:查找在指定时间曾被更改过内容的文件或目录,单位以分钟计算。
      • cmin <分钟>:查找在指定时间曾被更改过权限属性的文件或目录,单位以分钟计算。-ctime对应小时。
      • -amin <分钟>:查找的是指定时间访问过的文件或目录。-atim对应小时。
      • -perm <权限数值>:查找符合指定权限数值(有关权限数值见第6章)的文件或目录。如配置为“0700”,find命令会查找权限数值正好是“0700”的文件或目录;配置为“+0700”,find命令会查找权限数值大于 “0700”的文件或目录;配置为“-0700”,find

      选项大概有以下几类:

      1.按时间范围查找

      2.按文件大小查找

      3.按文件名称查找

      4.按其他:比如权限、用户组、类型等

      示例:

      #从根目开始,查找名称以nginx开头的目录和文件
      find / -name nginx*  
      
      #查找文件大小超过100M的文件
      find / -size +100M
      
      #查找/home/zx目录下,10分钟内被修改过的文件和目录
      find /home/zx/  -mmin -10
      
    • locate: 查找文件或目录(不常用)

      locate 查找内容
      

      例如:locate nginx 会将所有包含nginx的目录和文件都列出来。可以用* 或?等匹配符。

      locate的查找速度非常快,因为该命令查找的是数据库,所以有些刚修改的文件和目录,可能无法找到。可以采用:updatedb 命令更新数据库。

    • which: 查找文件(不常用)

      which [文件]
      

      which命令只会在PATH环境变量定义的路径及命令别名中查找,所以范围有限。

    • whereis : 查找文件(不常用)

      whichis [-bu] [-B<目录>] [-M<目录>] [-S<目录>] [文件]
      

      常用选项:

      文件:要查找的命令

      -b: 只查找二进制文件

      -u: 查找不包含指定类型的文件

      -B<目录>: 只在指定目录下查找二进制文件

      -M<目录>:只在指定目录查找帮助文件

      -S<目录>:只在指定目录查找源码目录

      例如: 默认只会在指定目录查找(/bin ,/etc ,/usr)

      [root@VM_0_13_centos soft]# whereis nginx
      nginx: /usr/local/nginx /usr/local/nginx/sbin/nginx /usr/local/nginx/sbin/nginx.bak
      
      
    展开全文
  • c++文件操作大全

    万次阅读 多人点赞 2019-01-17 15:43:06
    c++文件操作大全 基于C的文件操作  在ANSI C中,对文件的操作分为两种方式,即流式文件操作和I/O文件操作,下面就分别介绍之。 一、流式文件操作 这种方式的文件操作有一个重要的结构FILE,FILE在stdio.h中定义...

    <--好消息!好消息!好消息!

    粉丝超过2000的公众号主快来接单吧,快来领取你的第一笔广告费。(粉丝数不够的小伙伴,请私信我一并解决)
    新用户注册红包1.8元,新用户注册并接单红包9.9元。
    绑定有赚并接单成功的小伙伴,来找我领大红包。
    具体操作指导可加我微信(lizaozhizao)私信我。(本人亲测,真实有效,非广告)
    点击下面链接直接注册(选流量主)。
    2021年,流量变现年,不要错过,只要有公众号,有视频号,有流量,就能变现。大家都在做自媒体变现,你为什么也不尝试一下呢?

    https://a.newrank.cn/link/tkfomO

    -->

    c++文件操作大全

    基于C的文件操作 
      在ANSI C中,对文件的操作分为两种方式,即流式文件操作和I/O文件操作,下面就分别介绍之。

    一、流式文件操作 
    这种方式的文件操作有一个重要的结构FILE,FILE在stdio.h中定义如下:

    复制代码

    typedef struct { 
      int level;           /* fill/empty level of buffer */ 
      unsigned flags;        /* File status flags */ 
      char fd;            /* File descriptor */ 
      unsigned char hold;      /* Ungetc char if no buffer */ 
      int bsize;           /* Buffer size */ 
      unsigned char _FAR *buffer; /* Data transfer buffer */ 
      unsigned char _FAR *curp;  /* Current active pointer */ 
      unsigned istemp;      /* Temporary file indicator */ 
      short token;          /* Used for validity checking */ 
    } FILE;              /* This is the FILE object */ 

    复制代码

      FILE这个结构包含了文件操作的基本属性,对文件的操作都要通过这个结构的指针来进行,此种文件操作常用的函数见下表 函数 功能 

      fopen() 打开流 
      fclose() 关闭流 
      fputc() 写一个字符到流中 
      fgetc() 从流中读一个字符 
      fseek() 在流中定位到指定的字符 
      fputs() 写字符串到流 
      fgets() 从流中读一行或指定个字符 
      fprintf() 按格式输出到流 
      fscanf() 从流中按格式读取 
      feof() 到达文件尾时返回真值 
      ferror() 发生错误时返回其值 
      rewind() 复位文件定位器到文件开始处 
      remove() 删除文件 
      fread() 从流中读指定个数的字符 
      fwrite() 向流中写指定个数的字符 
      tmpfile() 生成一个临时文件流 
      tmpnam() 生成一个唯一的文件名


    下面就介绍一下这些函数

    1.fopen() 
      fopen的原型是:FILE *fopen(const char *filename,const char *mode),fopen实现三个功能

      为使用而打开一个流 
      把一个文件和此流相连接 
      给此流返回一个FILR指针 
      参数filename指向要打开的文件名,mode表示打开状态的字符串,其取值如下表

      字符串 含义 
      "r" 以只读方式打开文件 
      "w" 以只写方式打开文件 
      "a" 以追加方式打开文件 
      "r+" 以读/写方式打开文件,如无文件出错 
      "w+" 以读/写方式打开文件,如无文件生成新文件

      一个文件可以以文本模式或二进制模式打开,这两种的区别是:在文本模式中回车被当成一个字符'/n',而二进制模式认为它是两个字符0x0D,0x0A;如果在文件中读到0x1B,文本模式会认为这是文件结束符,也就是二进制模型不会对文件进行处理,而文本方式会按一定的方式对数据作相应的转换。

      系统默认的是以文本模式打开,可以修改全部变量_fmode的值来修改这个设置,例如_fmode=O_TEXT;就设置默认打开方式为文本模式;而_fmode=O_BINARY;则设置默认打开方式是二进制模式。

      我们也可以在模式字符串中指定打开的模式,如"rb"表示以二进制模式打开只读文件,"w+t"或"wt+"表示以文本模式打开读/写文件。

      此函数返回一个FILE指针,所以申明一个FILE指针后不用初始化,而是用fopen()来返回一个指针并与一个特定的文件相连,如果成败,返回NULL。

      例:

      FILE *fp; 
      if(fp=fopen("123.456","wb")) 
      puts("打开文件成功"); 
      else 
      puts("打开文件成败");

    2.fclose() 
      fclose()的功能就是关闭用fopen()打开的文件,其原型是:int fclose(FILE *fp);如果成功,返回0,失败返回EOF。

      在程序结束时一定要记得关闭打开的文件,不然可能会造成数据丢失的情况,我以前就经常犯这样的毛病。

      例:fclose(fp);

    3.fputc() 
      向流写一个字符,原型是int fputc(int c, FILE *stream); 成功返回这个字符,失败返回EOF。

      例:fputc('X',fp);

    4.fgetc() 
      从流中读一个字符,原型是int fputc(FILE *stream); 成功返回这个字符,失败返回EOF。

      例:char ch1=fgetc(fp);

    5. fseek() 
      此函数一般用于二进制模式打开的文件中,功能是定位到流中指定的位置,原型是int fseek(FILE *stream, long offset, int whence);如果成功返回0,参数offset是移动的字符数,whence是移动的基准,取值是

      符号常量 值 基准位置 
      SEEK_SET 0 文件开头 
      SEEK_CUR 1 当前读写的位置 
      SEEK_END 2 文件尾部

      例:fseek(fp,1234L,SEEK_CUR);//把读写位置从当前位置向后移动1234字节(L后缀表示长整数)

      fseek(fp,0L,2);//把读写位置移动到文件尾

    6.fputs() 
      写一个字符串到流中,原型int fputs(const char *s, FILE *stream);

      例:fputs("I Love You",fp);

    7.fgets() 
      从流中读一行或指定个字符,原型是char *fgets(char *s, int n, FILE *stream); 从流中读取n-1个字符,除非读完一行,参数s是来接收字符串,如果成功则返回s的指针,否则返回NULL。

      例:如果一个文件的当前位置的文本如下

      Love ,I Have

      But ........

      如果用

      fgets(str1,4,file1);

      则执行后str1="Lov",读取了4-1=3个字符,而如果用

      fgets(str1,23,file1);

      则执行str="Love ,I Have",读取了一行(不包括行尾的'/n')。

    8.fprintf() 
      按格式输入到流,其原型是int fprintf(FILE *stream, const char *format[, argument, ...]);其用法和printf()相同,不过不是写到控制台,而是写到流罢了

      例:fprintf(fp,"%2d%s",4,"Hahaha");

    9.fscanf() 
      从流中按格式读取,其原型是int fscanf(FILE *stream, const char *format[, address, ...]);其用法和scanf()相同,不过不是从控制台读取,而是从流读取罢了。

      例:fscanf(fp,"%d%d" ,&x,&y);

    10.feof() 
      检测是否已到文件尾,是返回真,否则返回0,其原型是int feof(FILE *stream);

      例:if(feof(fp))printf("已到文件尾");

    11.ferror() 
      原型是int ferror(FILE *stream);返回流最近的错误代码,可用clearerr()来清除它,clearerr()的原型是void clearerr(FILE *stream);

      例:printf("%d",ferror(fp));

    12.rewind() 
      把当前的读写位置回到文件开始,原型是void rewind(FILE *stream);其实本函数相当于fseek(fp,0L,SEEK_SET);

      例:rewind(fp);

    13.remove() 
      删除文件,原型是int remove(const char *filename); 参数就是要删除的文件名,成功返回0。

      例:remove("c://io.sys");

    14.fread() 
      从流中读指定个数的字符,原型是size_t fread(void *ptr, size_t size, size_t n, FILE *stream);参数ptr是保存读取的数据,void*的指针可用任何类型的指针来替换,如char*、int *等等来替换;size是每块的字节数;n是读取的块数,如果成功,返回实际读取的块数(不是字节数),本函数一般用于二进制模式打开的文件中。

      例:

      char x[4230]; 
      FILE *file1=fopen("c://msdos.sys","r"); 
      fread(x,200,12 ,file1);//共读取200*12=2400个字节

    15.fwrite() 
      与fread对应,向流中写指定的数据,原型是size_t fwrite(const void *ptr, size_t size, size_t n, FILE *stream);参数ptr是要写入的数据指针,void*的指针可用任何类型的指针来替换,如char*、int *等等来替换;size是每块的字节数;n是要写的块数,如果成功,返回实际写入的块数(不是字节数),本函数一般用于二进制模式打开的文件中。

      例:

      char x[]="I Love You"; 
      fwire(x, 6,12,fp);//写入6*12=72字节

      将把"I Love"写到流fp中12次,共72字节

    16.tmpfile() 
      其原型是FILE *tmpfile(void); 生成一个临时文件,以"w+b"的模式打开,并返回这个临时流的指针,如果失败返回NULL。在程序结束时,这个文件会被自动删除。

      例:FILE *fp=tmpfile();

    17.tmpnam(); 
      其原型为char *tmpnam(char *s); 生成一个唯一的文件名,其实tmpfile()就调用了此函数,参数s用来保存得到的文件名,并返回这个指针,如果失败,返回NULL。

     

    borland c++ bulder的文件操作总结2

    二、直接I/O文件操作 
      这是C提供的另一种文件操作,它是通过直接存/取文件来完成对文件的处理,而上篇所说流式文件操作是通过缓冲区来进行;流式文件操作是围绕一个FILE指针来进行,而此类文件操作是围绕一个文件的"句柄"来进行,什么是句柄呢?它是一个整数,是系统用来标识一个文件(在WINDOWS中,句柄的概念扩展到所有设备资源的标识)的唯一的记号。此类文件操作常用的函数如下表,这些函数及其所用的一些符号在io.h和fcntl.h中定义,在使用时要加入相应的头文件。

      函数 说明 
      open() 打开一个文件并返回它的句柄 
      close() 关闭一个句柄 
      lseek() 定位到文件的指定位置 
      read() 块读文件 
      write() 块写文件 
      eof() 测试文件是否结束 
      filelength() 取得文件长度 
      rename() 重命名文件 
      chsize() 改变文件长度

    下面就对这些函数一一说明:

    1.open() 
      打开一个文件并返回它的句柄,如果失败,将返回一个小于0的值,原型是int open(const char *path, int access [, unsigned mode]); 参数path是要打开的文件名,access是打开的模式,mode是可选项。表示文件的属性,主要用于UNIX系统中,在DOS/WINDOWS这个参数没有意义。其中文件的打开模式如下表。

      符号 含义 符号 含义 符号 含义 
      O_RDONLY 只读方式 O_WRONLY 只写方式 O_RDWR 读/写方式 
      O_NDELAY 用于UNIX系统 O_APPEND 追加方式 O_CREAT 如果文件不存在就创建 
      O_TRUNC 把文件长度截为0 O_EXCL 和O_CREAT连用,如果文件存在返回错误 O_BINARY 二进制方式 
      O_TEXT 文本方式

      对于多个要求,可以用"|"运算符来连接,如O_APPEND|O_TEXT表示以文本模式和追加方式打开文件。

      例:int handle=open("c://msdos.sys",O_BINARY|O_CREAT|O_WRITE)

    2.close() 
      关闭一个句柄,原型是int close(int handle);如果成功返回0

      例:close(handle)

    3.lseek() 
      定位到指定的位置,原型是:long lseek(int handle, long offset, int fromwhere);参数offset是移动的量,fromwhere是移动的基准位置,取值和前面讲的fseek()一样,SEEK_SET:文件首部;SEEK_CUR:文件当前位置;SEEK_END:文件尾。此函数返回执行后文件新的存取位置。

      例:

      lseek(handle,-1234L,SEEK_CUR);//把存取位置从当前位置向前移动1234个字节。 
      x=lseek(hnd1,0L,SEEK_END);//把存取位置移动到文件尾,x=文件尾的位置即文件长度

    4.read() 
      从文件读取一块,原型是int read(int handle, void *buf, unsigned len);参数buf保存读出的数据,len是读取的字节。函数返回实际读出的字节。

      例:char x[200];read(hnd1,x,200);

    5.write() 
      写一块数据到文件中,原型是int write(int handle, void *buf, unsigned len);参数的含义同read(),返回实际写入的字节。

      例:char x[]="I Love You";write(handle,x,strlen(x));

    6.eof() 
      类似feof(),测试文件是否结束,是返回1,否则返回0;原型是:int eof(int handle);

      例:while(!eof(handle1)){……};

    7.filelength() 
      返回文件长度,原型是long filelength(int handle);相当于lseek(handle,0L,SEEK_END)

      例:long x=filelength(handle);

    8.rename() 
      重命名文件,原型是int rename(const char *oldname, const char *newname); 参数oldname是旧文件名,newname是新文件名。成功返回0

      例:rename("c://config.sys","c://config.w40");

    9.chsize(); 
      改变文件长度,原型是int chsize(int handle, long size);参数size表示文件新的长度,成功返回0,否则返回-1,如果指定的长度小于文件长度,则文件被截短;如果指定的长度大于文件长度,则在文件后面补'/0'。

      例:chsize(handle,0x12345);


    --------------------------------------------------------------------------------

      如果熟悉汇编可能会发现这种方式和汇编语言的DOS功能调用句柄式文件操作很像,比如open()就像DOS服务的3CH号功能调用,其实这种操作还有两种类型的函数就是直接用DOS功能来完成的,如_open(),_dos_open()等等。有兴趣可自已查询BCB的帮助。

      同流式文件操作相同,这种也提供了Unicode字符操作的函数,如_wopen()等等,用于9X/NT下的宽字符编程,有兴趣可自已查询BCB的帮助。

      另外,此种操作还有lock(),unlock(),locking()等用于多用户操作的函数,但在BCB中用得并不多,我就不介绍了,但如果要用C来写CGI,这些就必要的常识了,如果你有这方面的要求,那就得自已好好看帮助了。

      到这里,我就把基于C的文件操作介绍完了,下一篇将介绍基于C++的文件操作,敬请期待。

    在C++中,有一个stream这个类,所有的I/O都以这个"流"类为基础的,包括我们要认识的文件I/O,stream这个类有两个重要的运算符:

    1、插入器(<<) 
      向流输出数据。比如说系统有一个默认的标准输出流(cout),一般情况下就是指的显示器,所以,cout<<"Write Stdout"<<'/n';就表示把字符串"Write Stdout"和换行字符('/n')输出到标准输出流。

    2、析取器(>>) 
      从流中输入数据。比如说系统有一个默认的标准输入流(cin),一般情况下就是指的键盘,所以,cin>>x;就表示从标准输入流中读取一个指定类型(即变量x的类型)的数据。

    在C++中,对文件的操作是通过stream的子类fstream(file stream)来实现的,所以,要用这种方式操作文件,就必须加入头文件fstream.h。下面就把此类的文件操作过程一一道来。

    一、打开文件 
      在fstream类中,有一个成员函数open(),就是用来打开文件的,其原型是:

      void open(const char* filename,int mode,int access);

      参数:

      filename:  要打开的文件名 
      mode:    要打开文件的方式 
      access:   打开文件的属性 
      打开文件的方式在类ios(是所有流式I/O类的基类)中定义,常用的值如下:

      ios::app:   以追加的方式打开文件 
      ios::ate:   文件打开后定位到文件尾,ios:app就包含有此属性 
      ios::binary:  以二进制方式打开文件,缺省的方式是文本方式。两种方式的区别见前文 
      ios::in:    文件以输入方式打开 
      ios::out:   文件以输出方式打开 
      ios::nocreate: 不建立文件,所以文件不存在时打开失败  
      ios::noreplace:不覆盖文件,所以打开文件时如果文件存在失败 
      ios::trunc:  如果文件存在,把文件长度设为0 
      可以用"或"把以上属性连接起来,如ios::out|ios::binary

      打开文件的属性取值是:

      0:普通文件,打开访问 
      1:只读文件 
      2:隐含文件 
      4:系统文件 
      可以用"或"或者"+"把以上属性连接起来 ,如3或1|2就是以只读和隐含属性打开文件。

      例如:以二进制输入方式打开文件c:/config.sys

      fstream file1; 
      file1.open("c://config.sys",ios::binary|ios::in,0);

      如果open函数只有文件名一个参数,则是以读/写普通文件打开,即:

      file1.open("c://config.sys");<=>file1.open("c://config.sys",ios::in|ios::out,0);

      另外,fstream还有和open()一样的构造函数,对于上例,在定义的时侯就可以打开文件了:

      fstream file1("c://config.sys");

      特别提出的是,fstream有两个子类:ifstream(input file stream)和ofstream(outpu file stream),ifstream默认以输入方式打开文件,而ofstream默认以输出方式打开文件。

      ifstream file2("c://pdos.def");//以输入方式打开文件 
      ofstream file3("c://x.123");//以输出方式打开文件

      所以,在实际应用中,根据需要的不同,选择不同的类来定义:如果想以输入方式打开,就用ifstream来定义;如果想以输出方式打开,就用ofstream来定义;如果想以输入/输出方式来打开,就用fstream来定义。


    二、关闭文件 
      打开的文件使用完成后一定要关闭,fstream提供了成员函数close()来完成此操作,如:file1.close();就把file1相连的文件关闭。

    三、读写文件 
      读写文件分为文本文件和二进制文件的读取,对于文本文件的读取比较简单,用插入器和析取器就可以了;而对于二进制的读取就要复杂些,下要就详细的介绍这两种方式

      1、文本文件的读写 
      文本文件的读写很简单:用插入器(<<)向文件输出;用析取器(>>)从文件输入。假设file1是以输入方式打开,file2以输出打开。示例如下:

      file2<<"I Love You";//向文件写入字符串"I Love You" 
      int i; 
      file1>>i;//从文件输入一个整数值。

      这种方式还有一种简单的格式化能力,比如可以指定输出为16进制等等,具体的格式有以下一些

      操纵符 功能 输入/输出 
      dec 格式化为十进制数值数据 输入和输出 
      endl 输出一个换行符并刷新此流 输出 
      ends 输出一个空字符 输出 
      hex 格式化为十六进制数值数据 输入和输出 
      oct 格式化为八进制数值数据 输入和输出 
      setpxecision(int p) 设置浮点数的精度位数 输出

      比如要把123当作十六进制输出:file1<
      2、二进制文件的读写 
      ①put() 
      put()函数向流写入一个字符,其原型是ofstream &put(char ch),使用也比较简单,如file1.put('c');就是向流写一个字符'c'。

      ②get() 
      get()函数比较灵活,有3种常用的重载形式:

      一种就是和put()对应的形式:ifstream &get(char &ch);功能是从流中读取一个字符,结果保存在引用ch中,如果到文件尾,返回空字符。如file2.get(x);表示从文件中读取一个字符,并把读取的字符保存在x中。

      另一种重载形式的原型是: int get();这种形式是从流中返回一个字符,如果到达文件尾,返回EOF,如x=file2.get();和上例功能是一样的。

      还有一种形式的原型是:ifstream &get(char *buf,int num,char delim='/n');这种形式把字符读入由 buf 指向的数组,直到读入了 num 个字符或遇到了由 delim 指定的字符,如果没使用 delim 这个参数,将使用缺省值换行符'/n'。例如:

      file2.get(str1,127,'A');//从文件中读取字符到字符串str1,当遇到字符'A'或读取了127个字符时终止。

      ③读写数据块 
      要读写二进制数据块,使用成员函数read()和write()成员函数,它们原型如下:

      read(unsigned char *buf,int num); 
      write(const unsigned char *buf,int num);

      read()从文件中读取 num 个字符到 buf 指向的缓存中,如果在还未读入 num 个字符时就到了文件尾,可以用成员函数 int gcount();来取得实际读取的字符数;而 write() 从buf 指向的缓存写 num 个字符到文件中,值得注意的是缓存的类型是 unsigned char *,有时可能需要类型转换。

      例:

      unsigned char str1[]="I Love You"; 
      int n[5]; 
      ifstream in("xxx.xxx"); 
      ofstream out("yyy.yyy"); 
      out.write(str1,strlen(str1));//把字符串str1全部写到yyy.yyy中 
      in.read((unsigned char*)n,sizeof(n));//从xxx.xxx中读取指定个整数,注意类型转换 
      in.close();out.close();

    四、检测EOF 
      成员函数eof()用来检测是否到达文件尾,如果到达文件尾返回非0值,否则返回0。原型是int eof();

      例:  if(in.eof())ShowMessage("已经到达文件尾!");

    五、文件定位 
      和C的文件操作方式不同的是,C++ I/O系统管理两个与一个文件相联系的指针。一个是读指针,它说明输入操作在文件中的位置;另一个是写指针,它下次写操作的位置。每次执行输入或输出时,相应的指针自动变化。所以,C++的文件定位分为读位置和写位置的定位,对应的成员函数是 seekg()和 seekp(),seekg()是设置读位置,seekp是设置写位置。它们最通用的形式如下:

      istream &seekg(streamoff offset,seek_dir origin); 
      ostream &seekp(streamoff offset,seek_dir origin);

      streamoff定义于 iostream.h 中,定义有偏移量 offset 所能取得的最大值,seek_dir 表示移动的基准位置,是一个有以下值的枚举:

      ios::beg:  文件开头 
      ios::cur:  文件当前位置 
      ios::end:  文件结尾 
      这两个函数一般用于二进制文件,因为文本文件会因为系统对字符的解释而可能与预想的值不同。

      例:

      file1.seekg(1234,ios::cur);//把文件的读指针从当前位置向后移1234个字节 
      file2.seekp(1234,ios::beg);//把文件的写指针从文件开头向后移1234个字节

     

    ------------------------------------------------------------------------------------------------------------------------------------------

    在BCB中也提供了文件操作的函数,这些函数的功能和前面所介绍的大致相同,但这类函数和BCB关系紧密,能使用BCB中的AnsiString等数据类型,在BCB中用这种方式的文件操作是最方便的,下面我就把这种文件操作详细介绍。

    在BCB提供的这组文件操作函数中,可分为三种类型,就是:1、文件名函数,2、文件管理函数;3、文件I/O函数。

    1、文件名函数 
      文件名函数可以对文件的名称、所在子目录、驱动器和扩展名等进行操作。下表列出这些函数及其功能。

      函数 说明 
      ExpandFileName() 返回文件的全路径(含驱动器、路径) 
      ExtractFileExt() 从文件名中抽取扩展名 
      ExtractFileName() 从文件名中抽取不含路径的文件名 
      ExtractFilePath() 从文件名中抽取路径名 
      ExtractFileDir() 从文件名中抽取目录名 
      ExtractFileDrive() 从文件名中抽取驱动器名 
      ChangeFileExt() 改变文件的扩展名 
      ExpandUNCFileName() 返回含有网络驱动器的文件全路径 
      ExtractRelativePath() 从文件名中抽取相对路径信息 
      ExtractShortPathName() 把文件名转化为DOS的8·3格式 
      MatchesMask() 检查文件是否与指定的文件名格式匹配

      下面就把这些函数作一一介绍:

      ⑴ExpandFileName() 
      原型:extern PACKAGE AnsiString __fastcall ExpandFileName(const AnsiString FileName);

      功能:返回文件的全路径(含驱动器、路径)

      参数:FileName:要处理的文件名

      例:ShowMessage(ExpandFileName(Application->ExeName));//显示你的程序文件名,如C:/MyBCB/Sample1.EXE

      ⑵ExtractFileExt() 
      原型:extern PACKAGE AnsiString __fastcall ExtractFileExt(const AnsiString FileName);

      功能:从文件名中抽取扩展名

      参数:FileName:要处理的文件名(全路径)

      例:ShowMessage(ExtractFileExt(Application->ExeName));//显示".exe"

      ⑶ExtractFileName() 
      原型:extern PACKAGE AnsiString __fastcall ExtractFileName(const AnsiString FileName);

      功能:从文件名中抽取不含路径的文件名

      参数:FileName:要处理的文件名

      例:ShowMessage(ExtractFileExt("c://Winnt//SOL.EXE"));//显示"SOL.EXE"

      ⑷ExtractFilePath() 
      原型:extern PACKAGE AnsiString __fastcall ExtractFilePath(const AnsiString FileName);

      功能:从文件名中抽取路径名

      参数:FileName:要处理的文件名

      例:ShowMessage(ExtractFilePath("Winnt//SOL.EXE"));//显示"Winnt/"

      ⑸ExtractFileDir() 
      原型:extern PACKAGE AnsiString __fastcall ExtractFileDir(const AnsiString FileName);

      功能:从文件名中抽取目录名(和上个函数不同,不包括最后的"/")

      参数:FileName:要处理的文件名

      例:ShowMessage(ExtractFileDir("Winnt//SOL.EXE"));//显示"Winnt",注意和上个函数的区别

      ⑹ExtractFileDrive() 
      原型:extern PACKAGE AnsiString __fastcall ExtractFileDrive(const AnsiString FileName);

      功能:从文件名中抽取驱动器名

      参数:FileName:要处理的文件名

      例:ShowMessage(ExtractFileDrive("c://Winnt//SOL.EXE"));//显示"c:"

      ⑺ChangeFileExt() 
      原型:extern PACKAGE System::AnsiString __fastcall ChangeFileExt(const System::AnsiString FileName, const System::AnsiString Extension);

      功能:更改文件名的扩展名,不是对真正的文件进行改名,只是对文件名这个字符串进行处理

      参数:FileName:要改名的文件名,Extension:新的扩展名

      例:ShowMessage(ChangeFileExt("c://Winnt//SOL.EXE",".OOO"));//显示"c:/winnt/SOL.OOO"

      ⑻ExpandUNCFileName() 
      原型:extern PACKAGE AnsiString __fastcall ExpandUNCFileName(const AnsiString FileName);

      功能:返回含有网络驱动器的文件全路径,格式为://机器名/共享名/文件名

      参数:FileName:要处理的文件名

      例:ShowMessage(ExpandUNCFileName("F://Winnt//SOL.EXE"));/*如果F:是映射的网络驱动器//NT40/WINNT,则显示"//NT40/WINNT/SOL.EXE"*/

      ⑼ExtractRelativePath() 
      原型:extern PACKAGE AnsiString __fastcall ExtractRelativePath(const AnsiString BaseName, const AnsiString DestName);

      功能:从文件名中抽取相对路径信息,如"../sss/ss.asd"这种形式

      参数:BaseName:基准文件名;DestName:目标文件名

      例:ShowMessage(ExtractRelativePath("D://Source//c//1.123","D://Source//Asm//dz.asm"));/*显示"../asm/dz.asm"*/

      (10) ExtractShortPathName() 
      原型:extern PACKAGE AnsiString __fastcall ExtractShortPathName(const AnsiString FileName);

      功能:把文件名转换为DOS的8、3格式

      参数:FileName:要处理的文件名

      例:ShowMessage(ExtractShortPathName("E://Program Files//Dual Wheel Mouse//4dmain.exe"));/*显示"E:/Progra~1/dualwh~1/4dmain.exe"*/

      ⑾MatchesMask() 
      原型:extern PACKAGE bool __fastcall MatchesMask(const AnsiString Filename, const AnsiString Mask);

      功能:检查文件是否与指定的文件名格式匹配

      参数:FileName:要处理的文件名;Mask:文件名格式,支持通配符

      例:ShowMessage(MatchesMask("Lxf.exe","*.?x?));//显示"true"

    2、文件管理函数 
      这类函数包括设置和读取驱动器、子目录和文件的有关的各种操作,下表列出这类操作常用的函数及其功能。

      函数 功能 
      CreateDir() 创建新的子目录 
      DeleteFile() 删除文件 
      DirectoryExists() 判断目录是否存在 
      DiskFree() 获取磁盘剩余空间 
      DiskSize() 获取磁盘容量 
      FileExists() 判断文件是否存在 
      FileGetAttr() 获取文件属性 
      FileGetDate() 获取文件日期 
      GetCurrentDir() 获取当前目录 
      RemoveDir() 删除目录 
      SetCurrentDir() 设置当前目录

      下面就把这些函数作一一介绍:

      ⑴CreateDir() 
      原型:extern PACKAGE bool __fastcall CreateDir(const System::AnsiString Dir);

      功能:建立子目录,如果成功返回true,否则返回false

      参数:Dir:要建立的子目录的名字

      例:Create("ASM");//在当前目录下建立一个名为ASM的子目录

      ⑵DeleteFile() 
      原型:extern PACKAGE bool __fastcall DeleteFile(const System::AnsiString FileName);

      功能:删除文件,如果成功返回true,否则返回false

      参数:FileName:要删除的文件名

      例:if(OpenDialog1->Execute())DeleteFile(OpenDialog1->FileName);

      ⑶DirectoryExists() 
      原型:extern PACKAGE bool __fastcall DirectoryExists(const System:: AnsiString Name);

      功能:检测目录是否存在,如果存在返回true,否则返回false

      参数:Name:要检测的目录名

      例:if(!DirectoryExists("ASM"))CreateDir("ASM");//如果ASM这个目录不存在则创建之

      ⑷DiskFree() 
      原型:extern PACKAGE __int64 __fastcall DiskFree(Byte Drive);

      功能:检测磁盘剩余空间,返回值以字节为单位,如果指定的磁盘无效,返回-1

      参数:Drive:磁盘的代号,0表示当前盘, 1=A,2=B,3=C 以此类推

      例:ShowMessage(DiskFree(0));//显示当前盘的剩余空间

      ⑸DiskSize() 
      原型:extern PACKAGE __int64 __fastcall DiskSize(Byte Drive);

      功能:检测磁盘容量,返回值以字节为单位,如果指定的磁盘无效,返回-1

      参数:Drive:磁盘的代号,0表示当前盘, 1=A,2=B,3=C 以此类推

      例:ShowMessage(DiskFree(0));//显示当前盘的容量

      ⑹FileExists() 
      原型:extern PACKAGE bool __fastcall FileExists(const AnsiString FileName);

      功能:检测文件是否存在,如果存在返回true,否则返回false

      参数:FileName:要检测的文件名

      例:if(FileExists("AAA.ASM"))DeleteFile("AAA.ASM");

      ⑺FileGetAttr() 
      原型:extern PACKAGE int __fastcall FileGetAttr(const AnsiString FileName);

      功能:取得文件属性,如果出错返回-1

      返回值如下表,如果返回$00000006表示是一个具有隐含和系统属性的文件(4+2)

      常量 值 含义 
      faReadOnly $00000001 只读文件 
      faHidden $00000002 隐含文件 
      faSysFile $00000004 系统文件 
      faVolumeID $00000008 卷标 
      faDirectory $00000010 目录 
      faArchive $00000020 归档文件

      例:if(FileGetAttr("LLL.TXT")&0x2)ShowMessage("这是一个有隐含属性的文件");

      与此对应的有FileSetAttr() ,请自已查阅帮助系统


      ⑻FileGetDate() 
      原型:extern PACKAGE int __fastcall FileGetDate(int Handle);

      功能:返回文件的建立时间到1970-1-1日0时的秒数

      参数:Handle:用FileOpen()打开的文件句柄。

      例:

      int i=FileOpen("C://autoexec.bat",fmOpenRead); 
      ShowMessage(FileGetDate(i)); 
      FileClose(i);

      与此对应的有FileSetDate(),请自已查阅帮助系统

      ⑼GetCurrentDir() 
      原型:extern PACKAGE AnsiString __fastcall GetCurrentDir();

      功能:取得当前的目录名

      例:ShowMessage(GetCurrentDir());

      ⑽RemoveDir() 
      原型:extern PACKAGE bool __fastcall RemoveDir(const AnsiString Dir);

      功能:删除目录,如果成功返回true,否则返回false

      参数:Dir:要删除的目录名

      例:if(DiectoryExists("ASM"))RemoveDir("ASM");

      ⑾SetCurrentDir() 
      原型:extern PACKAGE bool __fastcall SetCurrentDir(const AnsiString Dir);

      功能:设置当前目录,如果成功返回true,否则返回false

      参数:Dir:要切换到的目录名

      例:SetCurrentDir("C://WINDOWS");


    3、文件I/O函数 
      这类函数完成对文件的读写相关的操作,这种类型的操作和C的基于I/O文件操作类似,下表列出这类操作常用的函数及其功能。


      FileOpen() 打开文件 
      FileClose() 关闭文件 
      FileRead() 读文件 
      FileSeek() 文件定位 
      FileWrite() 写文件 
      FileCreate() 创建文件

      下面就对这些函数作详细介绍。

      ⑴FileOpen() 
      原型:extern PACKAGE int __fastcall FileOpen(const AnsiString FileName, int Mode);

      功能:打开文件,如果成功返回其句柄,否则返回-1

      参数:FileName:要打开的文件名;Mode:打开的方式,取值如下表,可用"或"("|")运算符连接。

      常量 值 说明 
      ------------------------------------------------------------- 
      fmOpenRead 0 以只读属性打开 
      fmOpenWrite 1 以只写属性打开 
      fmOpenReadWrite 2 以读/写属性打开 
      fmShareCompat 0 兼容FCB方式(汇编中有相应的DOS功能调用,感兴趣自已查阅相关资料) 
      fmShareExclusive 16 共享方式:以独占方式打开,在关闭以前,别人不能访问 
      fmShareDenyWrite 32 共享方式:拒绝写访问 
      fmShareDenyRead 48 共享方式:拒绝读访问 
      fmShareDenyNone 64 共享方式:无限制,允许读写 
      例:int i=FileOpen("C://WINDOWS//Win.ini",fmOpenReadWrite|fmShareExclusive);

      ⑵FileClose() 
      原型:extern PACKAGE void __fastcall FileClose(int Handle);

      功能:关闭打开的句柄。

      参数:Handle:要关闭的句柄

      例:FileClose(i);

      ⑶FileRead() 
      原型:extern PACKAGE int __fastcall FileRead(int Handle, void *Buffer, int Count);

      功能:读文件,返回实际读取的字节数,句柄必须首先由FileOpen或FileCreate创建。

      参数:Handle:要读取的句柄;Buffer:存放读取的数据的缓冲区;Count:想读取的字节数

      例:char str[400];FileRead(hnd1,str,400);

      ⑷FileSeek() 
      原型:extern PACKAGE int __fastcall FileSeek(int Handle, int Offset, int Origin);

      功能:移动文件读取指针,成功返回文件指针的位置,失败返回-1

      参数:Handle:相关联的句柄;Offset:移动的量;Orgin:移动的基准,0=文件头,1=当前位置,2=文件尾。

      例:ShowMessage(FileSeek(hnd1,0,2));//取得文件的长度

      ⑸FileWrite() 
      原型:extern PACKAGE int __fastcall FileWrite(int Handle, const void *Buffer, int Count);

      功能:写文件,返回实际写入的字节数,句柄必须首先由FileOpen或FileCreate创建。

      参数:Handle:要写入的句柄;Buffer:存放写入数据的缓冲区;Count:想写入的字节数

      例:char str[]="I Love You";FileWrite(hnd1,str,strlen(str));

      ⑹FileCreate() 
      原型:extern PACKAGE int __fastcall FileCreate(const AnsiString FileName);

      功能:创建文件。成功返回其句柄,否则返回-1

      参数:FileName:要创建的文件名

      例:if(!FileExists("KC.C"))hnd1=FileCreate("KC.C");


    更多技巧文章、优秀资源下载:

    最通俗的解读,最深刻的干货,最简洁的教程,众多你不知道的小技巧等你来发现!

    欢迎关注公众号:「智阅荟」,懂技术,更懂你!

    请自行搜索“智阅荟”,暂不显示二维码。

    说明:本站提供的所有软件已经过360、火绒安全检测,在使用中如有问题可在公众号留言!

    展开全文
  • 2.5 Python文件操作

    万次阅读 2019-05-22 15:23:21
    2.5 Python文件操作 文件操作主要讲解以下内容: 1.文件本身的操作(python内置) 2.系统中文件和文件夹的操作(os和shutil模块当中) 3.系统路径相关操作(os模块中的子模块 os.path) 文件的基本操作: ...

    2.5 Python文件操作

    2.5 Python文件操作

    • 文件操作主要讲解以下内容:
      • 1.文件本身的操作(python内置)
      • 2.系统中文件和文件夹的操作(os和shutil模块当中)
      • 3.系统路径相关操作(os模块中的子模块 os.path)

    文件的基本操作:

    • open() 打开或者创建一个文件
        格式:open('文件路径','打开模式')
        返回值:文件io对象
    
        打开模式一共N种:
    
            w模式 写模式write  文件不存在时会创建文件,如果文件已存在则会清空文件
    
            r模式  读模式read  文件不存在就报错,存在则准备读取文件
    
            a模式 追加模式 append 文件不存在则新建,文件存在则在文件末尾追加内容
    
            x模式 抑或模式 xor 文件存在则报错,文件 不存在则新建文件
    
            b模式 二进制模式 binary 辅助模式不能单独使用
    
            +模式 增强模式plus  也是辅助模式不能单独使用
    
    • 以上模式可以互相组合:wrax不可以互相组合:
    模式说明
    r以只读方式打开文件。文件的指针将会放在文件的开头。这是默认模式。
    w打开一个文件只用于写入。如果该文件已存在则将其覆盖。如果该文件不存在,创建新文件。
    a打开一个文件用于追加。如果该文件已存在,文件指针将会放在文件的结尾。也就是说,新的内容将会被写入到已有内容之后。如果该文件不存在,创建新文件进行写入。
    rb以二进制格式打开一个文件用于只读。文件指针将会放在文件的开头。这是默认模式。
    wb以二进制格式打开一个文件只用于写入。如果该文件已存在则将其覆盖。如果该文件不存在,创建新文件。
    ab以二进制格式打开一个文件用于追加。如果该文件已存在,文件指针将会放在文件的结尾。也就是说,新的内容将会被写入到已有内容之后。如果该文件不存在,创建新文件进行写入。
    r+打开一个文件用于读写。文件指针将会放在文件的开头。
    w+打开一个文件用于读写。如果该文件已存在则将其覆盖。如果该文件不存在,创建新文件。
    a+打开一个文件用于读写。如果该文件已存在,文件指针将会放在文件的结尾。文件打开时会是追加模式。如果该文件不存在,创建新文件用于读写。。
    rb+以二进制格式打开一个文件用于读写。文件指针将会放在文件的开头。
    wb+以二进制格式打开一个文件用于读写。如果该文件已存在则将其覆盖。如果该文件不存在,创建新文件。
    ab+以二进制格式打开一个文件用于追加。如果该文件已存在,文件指针将会放在文件的结尾。如果该文件不存在,创建新文件用于读写。
    • close() 关闭文件
    格式:文件io对象.close()
    返回值:None
    
    • 示例如下:
        # 新建一个文件,文件名为:test.txt
        f = open('test.txt', 'w')
    
        # 关闭这个文件
        f.close()
    

    读写函数:

    • read() 读取文件
        格式:文件io对象.read()
        返回值:整个文件的字符
    
        格式:文件io对象.read(字符长度)
        返回值:指定长度的字符
    
    f = open('test.txt', 'r')
    
    content = f.read(5)
    
    print(content)
    
    print("-"*30)
    
    content = f.read()
    
    print(content)
    
    f.close()
    
    • readline() 读取一行文件
        格式:文件io对象.readline()
        返回值:一行内容的字符串
    
        格式:文件io对象.readline(字符长度)
        返回值:一行内容的字符串
    
        注意:字符长度<当前行内内容,则读取指定长度的字符串,并且下次再读取还是在
              这个一行中获取没有读取的内容。字符长度>=当前行内容,直接读取当前行
    
    #coding=utf-8
    
    f = open('test.txt', 'r')
    
    content = f.readline()
    print("1:%s"%content)
    
    content = f.readline()
    print("2:%s"%content)
    
    f.close()
    
    • readlines() 将文件中的内容读取到序列当中。
        格式:文件io对象.readlines()
        返回值:列表
    
        格式:文件io对象.readlines(字符长度)
        返回值:列表
    
        注意:读取的行数由字符长度决定,如果字符长度读取了N行后,还有指定长度的字符
              没有读取,则直接读取下一行进来
    
    #coding=utf-8
    
    f = open('test.txt', 'r')
    
    content = f.readlines()
    
    print(type(content))
    
    i=1
    for temp in content:
        print("%d:%s"%(i, temp))
        i+=1
    
    f.close()
    
    • write() 写入文件
        格式:文件io对象.write(字符串)
        返回值:写入字符串的长度
    
    • writelines() 将序列写入文件中
        格式:文件io对象.writelines(序列)
        返回值:None
    
    • truncate() 字符串截取操作
        格式:文件io对象.truncate(字节长度)
        返回值:截取的字节长度
    

    OS模块:

    • OS – 操作系统的简称
    • os模块就是对操作系统进行操作
    • 使用该模块必须先导入模块:
        import os
    

    os模块中的函数:

    序号函数名称描述格式
    1getcwd()获取当前的工作目录格式:os.getcwd()
    返回值:路径字符串
    2chdir()修改当前工作目录格式:os.chdir()
    返回值:None
    3listdir()获取指定文件夹中的所有文件和文件夹组成的列表 格式:os.listdir(目录路径)
    返回值:目录中内容名称的列表
    4mkdir()创建一个目录/文件夹格式:os.mkdir(目录路径)
    返回值:None
    5makedirs()递归创建文件夹格式:os.makedirs(路径)
    6rmdir()移除一个目录(必须是空目录)格式:os.rmdir(目录路径)
    返回值:None
    7removedirs()递归删除文件夹格式:os.removedirs(目录路径)
    返回值:None
    注意最底层目录必须为空
    8rename()修改文件和文件夹的名称格式:os.rename(源文件或文件夹,目标文件或文件夹)
    返回值:None
    9stat()获取文件的相关信息格式:os.stat(文件路径)
    返回值:包含文件信息的元组
    10system()执行系统命令格式:os.system()
    返回值:整型
    慎用! 玩意来个rm -rf 你就爽了!
    11getenv()获取系统环境变量格式:os.getenv(获取的环境变量名称)
    返回值:字符串
    12putenv()设置系统环境变量格式:os.putenv(‘环境变量名称’,值)
    返回值:无
    13exit()推出当前执行命令,直接关闭当前操作格式:exit()
    返回值:无

    当前os模块的值:

    序号函数名称描述
    1curdiros.curdir 获取当前路径 都是.
    2pardiros.pardir 获取上层目录路径 都是.
    3pathos.path os中的一个子模块,操作非常多
    4nameos.name 当前系统的内核名称 win->nt linux/unix->posix
    5sepos.sep 获取当前系统的路径分割符号 window -> \ linux/unix -> /
    6extsepos.extsep 获取当前系统中文件名和后缀之间的分割符号,所有系统都是.
    7linesepos.linesep 获取当前系统的换行符号 window -> \r\n linux/unix -> \n

    os.environ模块

    • os.environ 可以直接获取所有环境变量的信息组成的字典,如果希望更改环境变量,并且可以查询得到,就需要对os.environ进行操作

    • 该模块的所有方法均是字典的方法,可以通过字典的os.environ的结果进行操作。

    • 注意:无论使用os.getenv,putenv 还是使用os.environ进行环境变量的操作,都是只对当前脚本,临时设置而已,无法直接更新或者操作系统的环境变量设置。

    os.path模块

    • os.path是os模块中的子模块,包含很多和路径相关的操作

    • 函数部分:

    序号函数名称描述格式
    1abspath()将一个相对路径转化为绝对路径格式:os.path.abspath(相对路径)
    返回值:绝对路径字符串
    basename()获取路径中的文件夹或者文件名称(只要路径的最后一部分)格式:os.path.basename(路径)
    返回值:路径的最后一部分(可能是文件名也可能是文件夹名)
    3dirname()获取路径中的路径部分(出去最后一部分)格式:os.path.dirname(路径)
    返回值:路径中除了最后一部分的内容字符串
    4join()将2个路径合成一个路径格式:os.path.join(路径1,路径2)
    返回值:合并之后的路径
    5split()将一个路径切割成文件夹和文件名部分格式:os.path.split(路径)
    返回值:元组
    6splitext()将一个文件名切成名字和后缀两个部分格式:os.path.splitext(文件名称)
    返回值:元组 (名称,后缀)
    7getsize()获取一个文件的大小格式:os.path.getsize(路径)
    返回值:整数
    8检测一个路径是否是一个文件检测一个路径是否是一个文件格式:os.path.isfile(路径)
    返回值:布尔值
    9isdir()检测一个路径是否是一个文件夹格式:os.path.isdir(路径)
    返回值:布尔值
    10getctime()获取文件的创建时间! get create time格式:os.path.getctime(文件路径)
    返回值:时间戳浮点数
    11getmtime()获取文件的修改时间! get modify time格式:os.path.getmtime(文件路径)
    返回值:时间戳浮点数
    12getatime()获取文件的访问时间! get active time格式:os.path.getatime(文件路径)
    返回值:时间戳浮点数
    13exists()检测指定的路径是否存在格式:os.path.exists(路径)
    返回值:布尔值
    14isabs()检测一个路径是否是绝对路径格式:os.path.isabs(路径)
    返回值:布尔值
    15islink()检测一个路径是否是链接格式:os.path.islink(路径)
    返回值:布尔值
    16samefile()检测2个路径是否指向同一个文件格式:os.path.samefile(路径1,路径2)
    返回值:布尔值
    展开全文
  • C语言文件操作详解

    万次阅读 多人点赞 2015-12-11 16:46:40
    C语言文件操作函数 函数介绍 文件打开与关闭操作 fopen():文件打开操作 头文件:stdio.h 函数定义:FILE *fopen(char *pname, char *mode) 函数说明:pname是文件名,mode是打开文件的方式 mode:"r" 打开一...

    C语言文件操作函数

    函数介绍

    文件打开与关闭操作

    fopen():文件打开操作

    头文件:stdio.h
    函数定义:FILE *fopen(char *pname, char *mode)
    函数说明:pname是文件名,mode是打开文件的方式
    mode:"r" 打开一个已经存在的文件文本,文件不存在则出错



    以“r+”的方式打开一个文件,会清空文件的原始内容,重新写入数据

    返回值:正常返回:FILE *一个指向文件在内存中的文件信息去的开头

    异常返回:NULL,表示打开操作不成功

    打开文件的作用是:
    (1)分配给打开文件一个FILE 类型的文件结构体变量,并将有关信息填入文件结构体变量;
    (2)开辟一个缓冲区;
    (3)调用操作系统提供的打开文件或建立新文件功能,打开或建立指定文件;
    FILE *:指出fopen是一个返回文件类型的指针函数;

     返回值
       正常返回:被打开文件的文件指针。
       异常返回:NULL,表示打开操作不成功。

     要说明的是:C语言将计算机的输入输出设备都看作是文件。例如,键盘文件、屏幕文件等。ANSI C标准规定,在执行程序时系统先自动打开键盘、屏幕、错误三个文件。这三个文件的文件指针分别是:标准输入stdin、标准输出stdout和标准出错 stderr。

     fclose():文件关闭

    函数定义int fclose(FILE *fp);

    函数说明:fp是一个以打开的文件的文件指针

    返回值:

    正常返回:0

    异常返回:EOF,表示文件在关闭时发生错误


    fgetc:读取一个字符

    函数定义:int fgetc(FILE *fp)

    函数说明:从fp中读取一个字符,作为返回值返回

    返回值:

    正常返回:返回读取字符的代码

    异常返回:返回EOF。例如:要从“写打开”的文件中读取一个字符时,会发生错误而返回一个EOF

    【例8.1】显示指定文件的内容。

    //程序名为:display.c
    //执行时可用:display filename1 形式的命令行运行。显示文件filename1中的内容。例如,执行命令行display display.c将在屏幕上显示display的原代码。
    
    //File display program.
    #include <stdio.h>
    void main(int argc,char *argv[]) //命令行参数
    {
        int ch;//定义文件类型指针
        FILE *fp;//判断命令行是否正确
        if(argc!=2)
        {
            printf("Error format,Usage: display filename1\n");
            return; //键入了错误的命令行,结束程序的执行
        }
        //按读方式打开由argv[1]指出的文件
        if((fp=fopen(argv[1],"r"))==NULL)
        {
            printf("The file <%s> can not be opened.\n",argv[1]);//打开操作不成功
            return;//结束程序的执行
        }
        //成功打开了argv[1]所指文件
        ch=fgetc(fp); //从fp所指文件的当前指针位置读取一个字符
        while(ch!=EOF) //判断刚读取的字符是否是文件结束符
        {
            putchar(ch); //若不是结束符,将它输出到屏幕上显示
            ch=fgetc(fp); //继续从fp所指文件中读取下一个字符
        } //完成将fp所指文件的内容输出到屏幕上显示
        fclose(fp); //关闭fp所指文件
    }



    fputc:写一个字符到文件中

    函数定义:int fputc(int ch, FILE*fp)

    函数说明:ch是一个整型变量,要写到文件的字符

    fp:文件指针,要写入的文件

    返回值:

    正常返回:要写入的字符的代码

    异常返回:返回EOF

    【例8.2】将一个文件的内容复制到另一个文件中去。

    //程序名为:copyfile.c
    //执行时可用:copyfile filename1 filename2形式的命令行运行,将文件filename1中的内容复制到文件filename2中去。
    //file copy program.
    #include <stdio.h>
    void main(int argc,char *argv[]) //命令行参数
    {
        int ch;
        FILE *in,*out; //定义in和out两个文件类型指针
        if(argc!=3) //判断命令行是否正确
        {
            printf("Error in format,Usage: copyfile filename1 filename2\n");
            return; //命令行错,结束程序的执行
        }
        //按读方式打开由argv[1]指出的文件
        if((in=fopen(argv[1],"r"))==NULL)
        {
            printf("The file <%s> can not be opened.\n",argv[1]);
            return; //打开失败,结束程序的执行
        }
        //成功打开了argv[1]所指文件,再
        //按写方式打开由argv[2]指出的文件
        if((out=fopen(argv[2],"w"))==NULL)
        {
            printf("The file %s can not be opened.\n",argv[2]);
            return; //打开失败,结束程序的执行
        }
        //成功打开了argv[2]所指文件
        ch=fgetc(in); //从in所指文件的当前指针位置读取一个字符
        while(ch!=EOF) //判断刚读取的字符是否是文件结束符
        {
            fputc(ch,out); //若不是结束符,将它写入out所指文件
            ch=fgetc(in); //继续从in所指文件中读取下一个字符
        } //完成将in所指文件的内容写入(复制)到out所指文件中
        fclose(in); //关闭in所指文件
        fclose(out); //关闭out所指文件
    }


    【例8.3】按十进制和字符显示文件代码,若遇不可示字符就用井号"#"字符代替之。

    //程序名为:dumpf.c
    //执行时可用:dumpf filename1 形式的命令行运行。
    // File dump program.
    #include <stdio.h>
    void main(int argc,char *argv[])
    {
        char str[9];
        int ch,count,i;
        FILE *fp;
        if(argc!=2)
        {
            printf("Error format,Usage: dumpf filename\n");
            return;
        }
        if((fp=fopen(argv[1],"r"))==NULL)
        {
            printf("The file %s can not be opened.\n",argv[1]);
            return;
        }
        count=0;
        do{
            i=0;
            //按八进制输出第一列,作为一行八个字节的首地址
            printf("%06o: ",count*8);
            do{
                // 从打开的文件中读取一个字符
                ch=fgetc(fp);
                // 按十进制方式输出这个字符的ASCII码
                printf("%4d",ch);
                // 如果是不可示字符就用"#"字符代替
                if(ch<' '||ch>'~') str[i]='#';
                // 如果是可示字符,就将它存入数组str以便形成字符串
                else str[i]=ch;
                // 保证每一行输出八个字符
                if(++i==8) break;
            }while(ch!=EOF); // 遇到文件尾标志,结束读文件操作
            str[i]='\0'; // 在数组str加字符串结束标志
            for(;i<8;i++) printf(" "); // 一行不足八个字符用空格填充
            printf(" %s\n",str); // 输出字符串
            count++; // 准备输出下一行
        }while(ch!=EOF); // 直到文件结束
        fclose(fp); // 关闭fp所指文件
    }
    


    fgets():从文件中读取一个字符串

    函数定义:char *fgets(char *str, int n, FILE *fp)

    函数说明:由fp指出的文件中读取n-1个字符,并把他们存放到有str指出的字符数组中区,最后加上一个由字符串结束符'\0'

    参数说明:str:接受字符串的内存地址,可以是数组别名,也可以是指针

    n:指出要读取的字符的个数

    fp:这个是文件指针,指出要从中读取字符的文件

    返回值:

    正常返回:字符串的内存首地址,即str的值

    异常返回:返回一个NULL值,此时应当用feof()或ferror()函数来判别是读取到了文件尾,还是发生了错误。

    fputs():写入字符串到文件中去

    函数定义:把由str之处的字符串写入到fp所指的文件中去

    函数说明:

    str:之处要写入到文件中去的字符串,不包括最后的'\0'

    fp:这个是文件指针,之处字符串要写入到的文件指针

    返回值:

    正常返回:写入到的文件的字符个数,即字符串的长度

    非正常返回:返回一个NULL值,此时应当用feof()或ferror()函数来判别是读取到了文件尾,还是发生了错误。

    5.实例

    【例8.4】以下程序将一个文件的内容附加到另一个文件中去。

    //程序名:linkfile.c
    //执行时可用:linkfile filename1 filename2形式的命令行运行,将文件filename2的内容附加在文件filename1之后。
    // file linked program.
    #include <stdio.h>
    #define SIZE 512
    void main(int argc,char *argv[])
    {
        char buffer[SIZE];
        FILE *fp1,*fp2;
        if(argc!=3)
        {
            printf("Usage: linkfile filename1 filename2\n");
            return;
        }
        // 按追加方式打开argv[1] 所指文件
        if((fp1=fopen(argv[1],"a"))==NULL)
        {
            printf("The file %s can not be opened.\n",argv[1]);
            return;
        }
        if((fp2=fopen(argv[2],"r"))==NULL)
        {
            printf("The file %s can not be opened.\n",argv[2]);
            return;
        }
        // 读入一行立即写出,直到文件结束
        while(fgets(buffer,SIZE,fp1)!=NULL)
            printf("%s\n",buffer);
        while(fgets(buffer,SIZE,fp2)!=NULL)
            fputs(buffer,fp1);
        fclose(fp1);
        fclose(fp2);
        if((fp1=fopen(argv[1],"r"))==NULL)
        {
            printf("The file %s can not be opened.\n",argv[1]);
            return;
        }
        while(fgets(buffer,SIZE,fp1)!=NULL)
            printf("%s\n",buffer);
        fclose(fp1);
    }


    E. 往文件中写格式化数据

    1.函数原型

    int fprintf(FILE *fp,char *format,arg_list)

    2.功能说明
      将变量表列(arg_list)中的数据,按照format指出的格式,写入由fp指定的文件。fprintf()函数与printf()函数的功能相同,只是printf()函数是将数据写入屏幕文件(stdout)。
    3.参数说明
      fp:这是个文件指针,指出要将数据写入的文件。
      format:这是个指向字符串的字符指针,字符串中含有要写出数据的格式,所以该字符串成为格式串。格式串描述的规则与printf()函数中的格式串相同。
    arg_list:是要写入文件的变量表列,各变量之间用逗号分隔。
    4.返回值
      无。
    5. 实例

    【8.5】下列程序的执行文件为display.exe,执行时键入命令行:
       display [-i][-s] filename
    下面的表格列出了命令行参数的含义及其功能:

    //存储文件名:save.txt
    //程序代码如下:
    // file display program.
    #include <stdio.h>
    void main()
    {
        char name[10];
        int nAge,nClass;
        long number;
        FILE *fp;
        if((fp=fopen("student.txt","w"))==NULL)
        {
            printf("The file %s can not be opened.\n","student.txt");
            return;
        }
        fscanf(stdin,"%s %d %d %ld",name,&nClass,&nAge,&number);
        fprintf(fp,"%s %5d %4d %8ld",name,nClass,nAge,number);
        fclose(fp);
        if((fp=fopen("student.txt","r"))==NULL)
        {
            printf("The file %s can not be opened.\n","student.txt");
            return;
        }
        fscanf(fp,"%s %d %d %ld",name,&nClass,&nAge,&number);
        printf("name nClass nAge number\n");
        fprintf(stdout,"%-10s%-8d%-6d%-8ld\n",name,nClass,nAge,number);
        fclose(fp);
    }


    G. 以二进制形式读取文件中的数据

    1. 函数原型

    int fread(void *buffer,unsigned sife,unsigned count,FILE *fp)

    2. 功能说明
      从由fp指定的文件中,按二进制形式将sife*count个数据读到由buffer指出的数据区中。
    3. 参数说明
    buffer:这是一个void型指针,指出要将读入数据存放在其中的存储区首地址。
    sife:指出一个数据块的字节数,即一个数据块的大小尺寸。
    count:指出一次读入多少个数据块(sife)。
    fp:这是个文件指针,指出要从其中读出数据的文件。
    4.返回值
      正常返回:实际读取数据块的个数,即count。
      异常返回:如果文件中剩下的数据块个数少于参数中count指出的个数,或者发生了错误,返回0值。此时可以用feof()和ferror()来判定到底出现了什么
    情况。

    H. 以二进制形式写数据到文件中去

    1. 函数原型

    int fwrite(void *buffer,unsigned sife,unsigned count,FILE *fp)

    2. 功能说明
      按二进制形式,将由buffer指定的数据缓冲区内的sife*count个数据写入由fp指定的文件中去。
    3. 参数说明
    buffer:这是一个void型指针,指出要将其中数据输出到文件的缓冲区首地址。
    sife:指出一个数据块的字节数,即一个数据块的大小尺寸。
    count:一次输出多少个数据块(sife)。
    fp:这是个文件指针,指出要从其中读出数据的文件。
    4.返回值
      正常返回:实际输出数据块的个数,即count。
      异常返回:返回0值,表示输出结束或发生了错误。
    5.实例

    【例8.7】

    #include <stdio.h>
    #define SIZE 4
    struct worker
    { int number;
        char name[20];
        int age;
    };
    void main()
    {
        struct worker wk;
        int n;
        FILE *in,*out;
        if((in=fopen("file1.txt","rb"))==NULL)
        {
            printf("The file %s can not be opened.\n","file1.txt");
            return;
        }
        if((out=fopen("file2.txt","wb"))==NULL)
        {
            printf("The file %s can not be opened.\n","file2.txt");
            return;
        }
        while(fread(&wk,sizeof(struct worker),1,in)==1)
            fwrite(&wk,sizeof(struct worker),1,out);
        fclose(in);
        fclose(out);
    }


    I. 以二进制形式读取一个整数

    1. 函数原型

    int getw(FILE *fp)

    2. 功能说明
      从由fp指定的文件中,以二进制形式读取一个整数。
    3. 参数说明
      fp:是文件指针。
    4. 返回值
      正常返回:所读取整数的值。
      异常返回:返回EOF,即-1。由于读取的整数值有可能是-1,所以必须用feof()或ferror()来判断是到了文件结束,还是出现了一个出错。
    5. 实例

    【例8.8】

    #include <stdio.h>
    void main(int argc,char *argv[])
    {
        int i,sum=0;
        FILE *fp;
        if(argc!=2)
        {
            printf("Command error,Usage: readfile filename\n");
            exit(1);
        }
        if(!(fp=fopen(argv[1],"rb")))
        {
            printf("The file %s can not be opened.\n",argv[1]);
            exit(1);
        }
        for(i=1;i<=10;i++) sum+=getw(fp);
        printf("The sum is %d\n",sum);
        fclose(fp);
    }


    J. 以二进制形式存贮一个整数

    1.函数原型

    int putw(int n,FILE *fp)

    2. 功能说明
     以二进制形式把由变量n指出的整数值存放到由fp指定的文件中。
    3. 参数说明
     n:要存入文件的整数。
     fp:是文件指针。
    4. 返回值
     正常返回:所输出的整数值。
     异常返回:返回EOF,即-1。由于输出的整数值有可能是-1,所以必须用feof()或ferror()来判断是到了文件结束,还是出现了一个出错。
    5. 实例

    【例8.9】

    #include <stdio.h>
    void main(int argc,char *argv[])
    {
        int i;
        FILE *fp;
        if(argc!=2)
        {
            printf("Command error,Usage: writefile filename\n");
            return;
        }
    
        if(!(fp=fopen(argv[1],"wb")))
        {
            printf("The file %s can not be opened.\n",argv[1]);
            return;
        }
        for(i=1;i<=10;i++) printf("%d\n", putw(i,fp));
        fclose(fp);
    }


    * 文件状态检查

    A. 文件结束
    (1) 函数原型

    int feof(FILE *fp)

    (2) 功能说明
       该函数用来判断文件是否结束。
    (3) 参数说明
       fp:文件指针。
    (4) 返回值
       0:假值,表示文件未结束。
       1:真值,表示文件结束。
    (5) 实例

    【例8.10】

    #include <stdio.h>
    void main(int argc,char *argv[])
    {
        FILE *in,*out;
        char ch;
        if(argc!=3)
        {
            printf("Usage: copyfile filename1 filename2\n");
            return;
        }
        if((in=fopen(argv[1],"rb"))==NULL)
        {
            printf("The file %s can not be opened.\n",argv[1]);
            return;
        }
        if((out=fopen(argv[2],"wb"))==NULL)
        {
            printf("The file %s can not be opened.\n",argv[2]);
            return;
        }
        while(!feof(in))
        {
            ch=fgetc(in);
            if(ferror(in))
            {
                printf("read error!\n");
                clearerr(in);
            }
            else
            {
                fputc(ch,out);
                if(ferror(out))
                {
                    printf("write error!\n");
                    clearerr(out);
                }
            }
        }
        fclose(in);
        fclose(out);
    }


    B. 文件读/写出错
    (1) 函数原型

    int ferror(FILE *fp)

    (2) 功能说明
       检查由fp指定的文件在读写时是否出错。
    (3) 参数说明
       fp:文件指针。
    (4) 返回值
       0:假值,表示无错误。
       1:真值,表示出错。

    C. 清除文件错误标志

    (1) 函数原型

    void clearerr(FILE *fp)

    (2) 功能说明
       清除由fp指定文件的错误标志。
    (3) 参数说明
       fp:文件指针。
    (4) 返回值
       无。
    (5) 实例

    【例8.12】

    #include <stdio.h>
    void main(int argc,char *argv[])
    {
        FILE *in,*out;
        char ch;
        if(argc!=3)
        {
            printf("Usage: copyfile filename1 filename2\n");
            return;
        }
        if((in=fopen(argv[1],"rb"))==NULL)
        {
            printf("The file %s can not be opened.\n",argv[1]);
            return;
        }
        if((out=fopen(argv[2],"wb"))==NULL)
        {
            printf("The file %s can not be opened.\n",argv[2]);
            return;
        }
        while(!feof(in))
        {
            ch=fgetc(in);
            if(ferror(in))
            {
                printf("read error!\n");
                clearerr(in);
            }
            else
            {
                fputc(ch,out);
                if(ferror(out))
                {
                    printf("write error!\n");
                    clearerr(out);
                }
            }
        }
        fclose(in);
        fclose(out);
    }


    D. 了解文件指针的当前位置
    (1) 函数原型

    long ftell(FILE *fp)

    (2) 功能说明
       取得由fp指定文件的当前读/写位置,该位置值用相对于文件开头的位移量来表示。
    (3) 参数说明
       fp:文件指针。
    (4) 返回值
       正常返回:位移量(这是个长整数)。
       异常返回:-1,表示出错。
    (5) 实例

    * 文件定位

    A. 反绕
    (1) 函数原型

    void rewind(FILE *fp)

    (2) 功能说明
       使由文件指针fp指定的文件的位置指针重新指向文件的开头位置。
    (3) 参数说明
       fp:文件指针。
    (4) 返回值
       无。
    (5) 实例

    【例8.14】

    #include <stdio.h>
    void main()
    {
        FILE *in,*out;
        in=fopen("filename1","r");
        out=fopen("filename2","w");
        while(!feof(in)) fputc(fgetc(in),out);
        rewind(out);
        while(!feof(in)) putchar(fgetc(in));
        fclose(in);
        fclose(out);
    }

    B. 随机定位
    (1) 函数原型

    int fseek(FILE *fp,long offset,int base)

    (2) 功能说明
       使文件指针fp移到基于base的相对位置offset处。
    (3)参数说明
       fp:文件指针。
       offset:相对base的字节位移量。这是个长整数,用以支持大于64KB的文件。
       base:文件位置指针移动的基准位置,是计算文件位置指针位移的基点。ANSI C定义了base的可能取值,以及这些取值的符号常量。

    (4)返回值

      正常返回:当前指针位置。
      异常返回:-1,表示定位操作出错。

    (5)实例
    【例8.15】

    #include <stdio.h>
    #include <string.h>
    struct std_type
    {
        int num;
        char name[20];
        int age;
        char class;
    }stud;
    int cstufile()
    {
        int i;
        FILE *fp;
        if((fp=fopen("stufile","wb"))==NULL)
        {
            printf("The file can't be opened for write.\n");
            return 0;
        }
        for(i=1;i<=100;i++)
        {
            stud.num=i;
            strcpy(stud.name,"aaaa");
            stud.age=17;
            stud.class='8';
            fwrite(&stud,sizeof(struct std_type),1,fp);
        }
        fclose(fp);
        return 1;
    }
    void main()
    {
        int n;
        FILE *fp;
        if(cstufile()==0) return;
        if((fp=fopen("stufile","rb"))==NULL)
        {
            printf("The file can not be opened.\n");
            return;
        }
        for(n=0;n<100;n+=2)
        {
            fseek(fp,n*sizeof(struct std_type),SEEK_SET);
            fread(&stud,sizeof(struct std_type),1,fp);
            printf("%10d%20s%10d%4c\n",stud.num,stud.name,stud.age,stud.class);
        }
        fclose(fp);
    }


    * 关于exit()函数
    1. 函数原型

    void exit(int status)

    2. 功能说明
      exit()函数使程序立即终止执行,同时将缓冲区中剩余的数据输出并关闭所有已经打开的文件。
    3. 参数说明
      status:为0值表示程序正常终止,为非0值表示一个定义错误。
    4. 返回值
      无。

    * 关于feof()函数
    1. 函数原型

    int feof(FILE *fp)

    2. 功能说明
       在文本文件(ASCII文件)中可以用值为-1的符号常量EOF来作为文件的结束符。但是在二进制文件中-1往往可能是一个有意义的数据,因此不能用它 来作为文件的结束标志。为了能有效判别文件是否结束,ANSI C提供了标准函数feof(),用来识别文件是否结束。
    3. 参数说明
      fp:文件指针。
    4. 返回值
      返回为非0值:已到文件尾。
      返回为0值:表示还未到文件尾。

    展开全文
  • Python文件操作和访问数据库

    千人学习 2021-07-12 17:11:56
    初学者掌握了Python语法之后,文件操作和访问数据库是Python开发者必备的两项技能。   本课程讲授Python如何连接数据,对数据库进行增删改查。如何创建和修改文件。
  • C语言字符串常用操作函数C语言字符串、文件操作常用操作函数标准输入/输出重定向文件操作补充 C语言字符串、文件操作常用操作函数 字符串输出 - puts int puts(const char *str) 字符串写入到标准输出 stdout 字符...
  • jqm文件上传,上传图片,jqm的表单操作,jqm的ajax的使用,jqm文件操作大全,文件操作demo
  • Java文件操作

    万次阅读 多人点赞 2018-06-13 15:37:04
    Java文件操作 1、简介 Java中的File类给我们提供了文件操作的基础,本博客讲解的内容是工程训练任务2.1中的一些程序,对于写入操作在上一篇博客中已经有所涉及,故本博客只展示任务挑战中的三个小程序。 2、...
  • Objective-C文件和目录操作,NSFileManager使用文件操作: objective-c通过使用NSFileManager类来管理和操作文件、目录,NSFileManager,文件或目录是使用文件的路径名的唯一标示。每个路径名都是一个NSString对象。 ...
  • git 放弃修改,放弃增加文件操作

    万次阅读 多人点赞 2018-01-15 20:41:41
    1. 本地修改了一堆文件(并没有使用git add到暂存区),想放弃修改。 单个文件/文件夹: $ git checkout -- filename 所有文件/文件夹: $ git checkout . 2. 本地新增了一堆文件(并没有git add到暂存区),想...
  • 文件操作文件操作柄,NSFileHandle

    千次阅读 2012-08-17 14:24:23
    利用 文件操作柄,也就是 NSFileHandle这类物件,我们 可以更加近距离地 操作 文件。一般来说,操作 文件 需要 下面三个步骤: 打开 文件,为 这个文件 创建 文件操作柄;进行 输入/输出操作;关闭 文件。 ...
  • FTP文件操作之删除文件

    万次阅读 2013-04-22 10:15:45
    FTP文件操作之上传文件 FTP文件操作之下载文件 FTP文件操作之删除文件 FTP文件操作之创建目录 FTP文件操作之获取文件列表 上面我已经介绍了利用ftp进行上传跟下载,接下来跟大家分享的是删除ftp服务器上...
  • 1、linux文件夹和文件查看命令 linux使用ls查看当前目录下的...2、linux文件夹和文件操作命令 文件夹操作命令: mkdir + 文件夹名称 表示创建文件夹 文件操作命令: touch 表示新建任何类型的文件 rm -r...
  • 23. Perl 文件操作-文件类型判断

    千次阅读 2019-08-27 16:03:19
    perl 语言提供了很多对于判断文件属性的操作符, 笔者只列出个人常用的一些文件操作符. 文件属性判断操作符通常与if 配合使用. 1. 常用文件操作符 1.1 判断文件权限 测试操作符 含义 -r 当前...
  • FTP文件操作之获取文件列表

    万次阅读 热门讨论 2013-05-22 10:23:55
    FTP文件操作之上传文件 FTP文件操作之下载文件 FTP文件操作之删除文件 FTP文件操作之创建目录 FTP文件操作之获取文件列表 前面已经介绍了很多关于FTP对文件的操作,今天再跟大家介绍一个获取文件...
  • MAC终端命令-文件操作、编辑操作

    万次阅读 多人点赞 2018-07-27 22:59:12
    终端命令: 基本路径操作 相对路径:cd /users/yang/Desktop...文件操作 查看文件路径 ls:  ls 查看当前路径下的文件及文件夹的名字 ls /bin 表示:查看当前路径下的Documents文件夹下的所有东西 ls Docu...
  • 一、文件操作基础 读写文件是最常见的IO操作。 Python内置了读写文件的函数open()。 在读写文件前,我们先必须了解一下,在磁盘上读写文件的功能都是由操作系统提供的,现代操作系统不允许普通的程序直接操作磁盘,...
  • Java文件操作(超详细+代码示例)

    万次阅读 多人点赞 2019-04-21 21:26:03
    Java文件操作一、Java.io包1.1 File类1.2 Stream流1.2.1 使用FileInputStream类1.2.2 使用FileOutputStream类二、序列化 我们日常使用电脑的时候,基本都会和文件打交道,比如我们做ppt,或者写论文的时候,我们打开...
  • 我的博客——Java文件操作系列 【Java文件操作(一)】递归打印文件目录 【Java文件操作(二)】删除文件夹,但保留其内部文件 【Java文件操作(三)】递归复制文件夹内所有文件 【Java文件操作(四)】递归套递归,...
  • windows-cmd终端文件操作命令

    千次阅读 2019-04-18 10:56:32
    1 目录操作: 切入盘符: 直接d: 、c:,盘名加冒号 切入文件夹: ...2 文件操作: 新建文件: cd > a.txt type nul > a.txt 删除文件: del a.txt 打开编辑文件: 直接输入文件名 a....
  • Objective-C使用NSFileHandle类对文件进行基本操作,IOS文件操作 NSFileHandle类中得方法可以对文件进行基本的读写,偏移量的操作。 NSFileHandle基本步骤: 1、打开文件,获取一个NSFileHandle对象。 2、对...
  • 我的博客——Java文件操作系列 【Java文件操作(一)】递归打印文件目录 【Java文件操作(二)】删除文件夹,但保留其内部文件 【Java文件操作(三)】递归复制文件夹内所有文件 【Java文件操作(四)】递归套...
  • Linux-文件操作

    万次阅读 2018-04-08 00:18:18
    一、基本操作 1、新建文件 touch 文件名 2、新建文件夹 mkdir 目录名 mkdir -p a/b/c mkdir -m 755 目录名 3、复制文件或目录 cp 源文件 目标文件 cp -R 目录 目标位置 4、删除...
  • Python之Json文件操作

    万次阅读 2017-05-12 13:43:38
    Python之Json文件操作 Python对Json文件的操作主要用到的model是:json, 所以首先我们要把json加载进来: import json 然后我们用到的是json下的 json.load / json.dumps 函数,结合IO的基本文件...
  • 用Python对计算机文件进行操作的教学
  • java文件操作之移动文件到指定的目录 代码下载地址:http://www.zuidaima.com/share/1550463261166592.htm
  • VC文件操作

    万次阅读 2013-03-02 22:55:44
    在VC中文件操作有三种方式,使用C标准库,使用WINAPI或使用MFC库 一.C标准库 1.创建打开文件fopen FILE *fopen(const char* filename, Const char* mode)//相应有Unicode版本 _wfopen filename文件名 还有基于...
  • FTP文件操作之创建目录

    万次阅读 2013-05-13 21:30:40
    FTP文件操作之上传文件 FTP文件操作之下载文件 FTP文件操作之删除文件 FTP文件操作之创建目录 FTP文件操作之获取文件列表 前面几篇博客讲的都是对文件的操作,今天跟大家说一说对目录的操作...
  • HDFS常用的文件操作命令

    万次阅读 2018-03-22 11:16:01
    HDFS常用的文件操作命令 文件操作 查看文件命令 ls 命令 # 查看hdfs根目录 hdfs dfs -ls / # 查看hdfs其它目录(/user/zhang) hdfs dfs -ls /user/zhang du 命令 hdfs dfs -du /user/zhang # 将字节...
  • 我的博客——Java文件操作系列 【Java文件操作(一)】递归打印文件目录 【Java文件操作(二)】删除文件夹,但保留其内部文件 【Java文件操作(三)】递归复制文件夹内所有文件 【Java 文件操作(四)】递归套...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 5,914,588
精华内容 2,365,835
关键字:

文件操作