9.4 文件IO基本操作

fopen后必须判断 FILE *p  是否返回NULL

fopen打开文件后,一定要fclose


feof  判断文件是否到达最后

对一个文件进行简单的加密解密操作

  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <string.h>
  4. #define S_KEY 10
  5. void code(const char * src , const char * dest)
  6. {
  7. FILE * fp1 = fopen( src , "r" );
  8. FILE * fp2 = fopen( dest , "w" );
  9. if( !fp1 || !fp2)
  10. {
  11. printf("打开文件失败\n");
  12. exit( -1 );
  13. }
  14. char buf[1024];
  15. int len = 0 , i = 0;
  16. while(fgets( buf , sizeof(buf) , fp1) != NULL)
  17. {
  18. len = strlen(buf);
  19. for( i = 0 ; i < len ; ++i)
  20. buf[i] += S_KEY;
  21. fputs( buf , fp2);
  22. }
  23. }
  24. void decode(const char * src , const char * dest)
  25. {
  26. FILE * fp1 = fopen( src , "r" );
  27. FILE * fp2 = fopen( dest , "w" );
  28. if( !fp1 || !fp2)
  29. {
  30. printf("打开文件失败\n");
  31. exit( -1 );
  32. }
  33. char buf[1024];
  34. int len = 0 , i = 0;
  35. while(fgets( buf , sizeof(buf) , fp1) != NULL)
  36. {
  37. len = strlen(buf);
  38. for( i = 0 ; i < len ; ++i)
  39. buf[i] -= S_KEY;
  40. fputs( buf , fp2);
  41. }
  42. }
  43. int main(int argc , char * argv[])
  44. {
  45. if( argc < 4)
  46. {
  47. printf("参数一 是加密(1)或解密(2)\n");
  48. printf("参数二 是源文件\n参数三 是目标文件\n");
  49. exit(-1);
  50. }
  51. if( atoi(argv[1]) == 1)
  52. code(argv[2],argv[3]);
  53. else if(atoi(argv[1]) == 2)
  54. decode(argv[2],argv[3]);
  55. return 0;
  56. }

其他文件读写函数:

fprintf    是向一个文件写入东西 , 感觉类似 php 的 file_put_contents();

fscanf   可以从一个文件读入东西。不过遇到空格就会自动终止。

  1. #include <stdio.h>
  2. int main()
  3. {
  4. FILE *fp = fopen( "test.txt" , "r" ); //这个文件是有hello world 因为有空格 只能读出来hello
  5. char buf[100] ;
  6. fscanf( fp , "%s" , buf);
  7. printf("%s\n" , buf );
  8. fclose( fp);
  9. return 0;
  10. }

fopen的 b 模式

  1. FILE *p = fopen( "a.txt" , "wb");

b的意思是按照二进制的方式写文件

windows这个选项才有作用,linux可写可不写

例:

在windows下  没有b模式写入文件一个   \n 的时候  会自动写入 \r\n

如果有b的话,完全按照二进制方式写 只会写入 \n,如果要换行,必须强制写成\r\n

fopen的 r+ 模式

文件指针在开头,从文件开头覆盖原先的内容。

  1. #include <stdio.h>
  2. int main()
  3. {
  4. FILE *fp = fopen("a.txt","r+");
  5. if(!fp)
  6. {
  7. printf("打开文件失败\n");
  8. return -1;
  9. }
  10. char buf[1024] = "刘威";
  11. fputs(buf , fp);
  12. return 0;
  13. }

linux和windows通过网络传输文件(借助myudp)

  1. #define _CRT_SECURE_NO_WARNINGS
  2. #include <stdio.h>
  3. #include <string.h>
  4. #include <stdlib.h>
  5. #include "myudp.h"
  6. #pragma comment (lib,"myudp.lib")
  7. int main(int argc , char *argv[])
  8. {
  9. if(argc < 3)
  10. {
  11. printf("[./app] [FILE_NAME] [SEND:1] [IP]\n");
  12. printf("[./app] [FILE_NAME] [RECV:2]\n");
  13. return -1;
  14. }
  15. if( atoi(argv[2]) == 1)
  16. {
  17. FILE *fp = fopen( argv[1] , "r");
  18. if( !fp )
  19. {
  20. printf("打开文件失败\n");
  21. return -1;
  22. }
  23. if(argv[3] == NULL)
  24. {
  25. printf("请输入你需要发送的IP\n");
  26. return -1;
  27. }
  28. char buf[1024] , ch;
  29. while( !feof( fp ) )
  30. {
  31. memset(buf , 0 , sizeof(buf));
  32. fgets( buf , sizeof(buf) , fp );
  33. send_socket( argv[3], 8080, buf, sizeof(buf));
  34. }
  35. ch = EOF;
  36. send_socket( argv[3], 8080, &ch, sizeof(ch));
  37. fclose(fp);
  38. }
  39. else if( atoi(argv[2]) == 2) //接收的
  40. {
  41. FILE *fp = fopen( argv[1] , "w");
  42. if( !fp )
  43. {
  44. printf("打开文件失败\n");
  45. return -1;
  46. }
  47. char buf[1024];
  48. char IP[1024];
  49. bind_socket( 8080 );
  50. while( 1 )
  51. {
  52. memset( buf , 0 , sizeof(buf));
  53. memset( IP , 0 , sizeof(IP));
  54. recv_socket(buf, sizeof(buf), IP);
  55. if( buf[0] == EOF)
  56. break;
  57. fputs( buf , fp);
  58. }
  59. fclose(fp);
  60. }
  61. return 0;
  62. }

就可以把windows里的a.txt 发送到linux里

通过fgets和feof获取文件的行数:

  1. #include <stdio.h>
  2. int main()
  3. {
  4. FILE *fp = fopen("a.txt","r");
  5. char buf[1024];
  6. int count = 0;
  7. while(fgets(buf,sizeof(buf),fp))
  8. {
  9. count++;
  10. }
  11. printf("%d\n",count);
  12. return 0;
  13. }

此方法得到的行数是正确的。

  1. #include <stdio.h>
  2. int main()
  3. {
  4. char buf[1024];
  5. int count = 0;
  6. FILE *fp = fopen("a.txt","r");
  7. while(!feof(fp))
  8. {
  9. fgets(buf,sizeof(buf),fp);
  10. count++;
  11. }
  12. printf("%d\n",count);
  13. return 0;
  14. }

上面这种方法linux得到的行数比实际大 1,windows正常

读取一个文件的所有数字,进行排序,并且写入另外一个文件

  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <string.h>
  4. int file_count(FILE *fp)
  5. {
  6. char buf[1024] , len = 0;
  7. while( fgets( buf , sizeof(buf) , fp) != NULL )
  8. {
  9. len++;
  10. }
  11. rewind(fp);
  12. return len;
  13. }
  14. void show_array(int *p , int len)
  15. {
  16. int i;
  17. for( i = 0 ; i < len ; i++)
  18. printf("%d\n",p[i]);
  19. }
  20. //选择排序
  21. void sort_array(int *p , int len)
  22. {
  23. int i, j , min , tmp;
  24. for(i = 0 ; i < len ; ++i)
  25. {
  26. min = i;
  27. for(j = i+1 ; j < len ; ++j)
  28. if(p[min] > p[j])
  29. min = j;
  30. if(min != i)
  31. {
  32. tmp = p[i];
  33. p[i] = p[min];
  34. p[min] = tmp;
  35. }
  36. }
  37. }
  38. int main()
  39. {
  40. FILE *fp = fopen("t.txt" , "r");
  41. if(!fp)
  42. {
  43. printf("打开文件失败\n");
  44. return -1;
  45. }
  46. int len = file_count(fp) , i = 0;
  47. int *p = (int *)malloc(sizeof(int) * len);
  48. memset(p , 0 , sizeof(int) * len);
  49. char buf[1024] = {0};
  50. for( i = 0 ; i < len ; i++)
  51. {
  52. fgets( buf , sizeof(buf) , fp);
  53. p[i] = atoi(buf);
  54. }
  55. //show_array( p , len);
  56. sort_array( p , len);
  57. //show_array( p , len);
  58. FILE *fp2 = fopen("sort.txt" , "w");
  59. for( i = 0 ; i < len ; i++)
  60. fprintf(fp2 , "%d\n" , p[i]);
  61. free(p);
  62. fclose(fp);
  63. fclose(fp2);
  64. return 0;
  65. }

来自为知笔记(Wiz)

时间: 2024-10-24 22:14:04

9.4 文件IO基本操作的相关文章

文件IO大纲

文件流与文件描述符的区别 a) 任何进程在运行时都默认打开3个流对象,(stdin, stdout, stderr)它们都有对应的文件描述符,其文件描述符分别为0,1,2,以后打开的文件描述符的值一般都选用未使用的最小值 b) LINUX为管理每个每个进程打开的文件,在进程的私有结构体struct task_struct(即进程PCB,由内核提供)中,对任何进程来说,都将为这个结构体专门分配管理打开文件信息的表项,用以指示当前进程打开的文件结构体,通俗点解释就是每一个进程都在内核的struct

Unix高级编程之文件IO

文件io---低级io 特点: 不带缓存io优点: 实时性高 1.io基本操作 文件描述符:文件io打开文件的标识 非负整型数,是内核为打开文件维护结构的数组下标 默认最多能打开1024文件 stdin-----0 stdout-----1 stderr-----2 函数: open(2); read(2); write(2); lseek(2); <1>允许偏移的字节个数大于文件本身 <2>lseek()本身不进行读写操作 空洞文件 空洞文件本身不占用磁盘空间 close(2);

Andriod文件的基本操作(转)

1. 文件的基本操作 File类的相关技巧和操作:文件的创建.重命名和删除,文件夹的创建和删除等操作. 1 package control; 2 3 import java.io.File; 4 5 public class FileUtil { 6     public static final String FILE_NAME = "myfile.txt"; 7     public static final String FOlDER_NAME = "NewFolder

HDFS文件的基本操作

HDFS文件的基本操作: package wjn; import java.io.BufferedInputStream; import java.io.BufferedReader; import java.io.FileInputStream; import java.io.FileOutputStream; import java.io.IOException; import java.io.InputStream; import java.io.InputStreamReader; im

第七篇:两个经典的文件IO程序示例

前言 本文分析两个经典的C++文件IO程序,提炼出其中文件IO的基本套路,留待日后查阅. 程序功能 程序一打印用户指定的所有文本文件,程序二向用户指定的所有文本文件中写入数据. 程序一代码及其注释 1 #include <iostream> 2 #include <fstream> // 使用文件处理对象记着要包含这个头文件 3 #include <string> 4 #include <vector> 5 6 using namespace std; 7

MySQL系列:innodb引擎分析之文件IO

innodb作为数据库引擎,自然少不了对文件的操作,在innodb中所有需要持久化的信息都需要文件操作,例如:表文件.重做日志文件.事务日志文件.备份归档文件等.innodb对文件IO操作可以是煞费苦心,其主要包括两方面,一个是对异步io的实现,一个是对文件操作管理和io调度的实现.在MySQL-5.6版本的innodb还加入了DIRECT IO实现.做了这么多无非是优化io操作的性能.在innodb的文件IO部分中,主要实现集中在os_file.*和fil0fil.*两个系列的文件当中,其中o

Linux下用文件IO的方式操作GPIO(/sys/class/gpio)(转)

通过sysfs方式控制GPIO,先访问/sys/class/gpio目录,向export文件写入GPIO编号,使得该GPIO的操作接口从内核空间暴露到用户空间,GPIO的操作接口包括direction和value等,direction控制GPIO方向,而value可控制GPIO输出或获得GPIO输入.文件IO方式操作GPIO,使用到了4个函数open.close.read.write. 首先,看看系统中有没有"/sys/class/gpio"这个文件夹.如果没有请在编译内核的时候加入 

(二) 一起学 APUE 之 文件 IO

. . . . . 昨天我们讨论了标准 IO,今天主要说说系统 IO. 1.文件描述符 在 SYSIO 中贯穿了一个整形数,它就是文件描述符.对内核而言,所有打开的文件都是通过文件描述符引用的.它的作用与 STDIO 中的 FILE 结构体类似,但是它们的工作原理是完全不同的.它实际上是一个由内核保存的数组下标,所以不会是负数,下面我会用一张图来表示它的作用. 图1 SYSIO 文件描述符 图是在 Ubuntu 下好不容易找到了一个画图软件画的,质量不怎么样,小伙伴们先凑合着看吧. 我解释下图上

(一)一起学 APUE 之 文件 IO

. . . . . 最近在学习 APUE,所以顺便将每日所学记录下来,一方面为了巩固学习的知识,另一方面也为同样在学习APUE的童鞋们提供一份参考. 本系列博文均根据学习<UNIX环境高级编程>一书总结而来,如有错误请多多指教. APUE主要讨论了三部分内容:文件IO.并发.进程间通信. 文件IO: 标准IO:优点是可移植性高,缺点是性能比系统 IO 差,且功能没有系统 IO 丰富. 系统IO:因为是内核直接提供的系统调用函数,所以性能比标准 IO 高,但是可移植性比标准 IO 差. 并发: