创建临时文件

  1. #include <stdio.h>
  2. int main(int argc, char *argv[])
  3. {
  4. FILE *temp;
  5. char c;
  6. if ((temp = tmpfile()) != NULL)
  7. {
  8. fputs("hello lyshark\n", temp); // 向临时文件中写入要求内容
  9. }
  10. rewind(temp); // 文件指针返回文件首
  11. while ((c = fgetc(temp)) != EOF) // 读取临时文件中内容
  12. printf("%c", c);
  13. fclose(temp);
  14. return 0;
  15. }

重命名文件

  1. #include <stdio.h>
  2. int Rename_File(char *src_name, char *dst_name)
  3. {
  4. FILE *fp = fopen(src_name, "r");
  5. if (fp != NULL)
  6. {
  7. rename(src_name, dst_name);
  8. fclose(fp);
  9. }
  10. return 0;
  11. }
  12. int main(int argc, char* argv[])
  13. {
  14. Rename_File("c:/aaaa.log", "c:/lysharrr.log");
  15. system("pause");
  16. return 0;
  17. }

删除文件

  1. #include <stdio.h>
  2. int Delete_File(char *file_name)
  3. {
  4. FILE *fp;
  5. if ((fp = fopen(file_name, "r")) != NULL)
  6. fclose(fp);
  7. remove(file_name);
  8. if ((fp = fopen(file_name, "r")) == NULL)
  9. return 1;
  10. return 0;
  11. }
  12. int main(int argc, char* argv[])
  13. {
  14. Delete_File("c:/lyshark.log");
  15. system("pause");
  16. return 0;
  17. }

读文件并输出内容:

  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. int Read_File(FILE *fp)
  4. {
  5. if (fp == NULL)
  6. return 0;
  7. char ch;
  8. // while ((ch = fgetc(fp)) != EOF)
  9. while (!feof(fp))
  10. {
  11. ch = fgetc(fp);
  12. if (feof(fp))
  13. break;
  14. printf("%c", ch);
  15. }
  16. }
  17. int main(int argc, char* argv[])
  18. {
  19. FILE *fp = fopen("c:/lyshark.log", "r");
  20. Read_File(fp);
  21. system("pause");
  22. return 0;
  23. }

堆空间读取

  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. int main(int argc, char* argv[])
  4. {
  5. FILE *fp = fopen("c:/lyshark.log", "r");
  6. char *buffer = malloc(sizeof(char)* 1024);
  7. while (feof(fp) == 0)
  8. {
  9. memset(buffer, 0, 1024);
  10. fgets(buffer, 1024, fp);
  11. printf("%s", buffer);
  12. }
  13. system("pause");
  14. return 0;
  15. }

写入内容到文件:

  1. #include <stdio.h>
  2. #include <string.h>
  3. #include <stdlib.h>
  4. int Write_File(char *path, char *msg)
  5. {
  6. FILE *fp = fopen(path, "a+");
  7. if(fp== NULL) return -1;
  8. char ch, buffer[1024];
  9. int index = 0;
  10. while (msg[index] != '\0')
  11. {
  12. fputc(msg[index], fp);
  13. index++;
  14. }
  15. fclose(fp);
  16. return 1;
  17. }
  18. int main(int argc, char* argv[])
  19. {
  20. for (int x = 0; x < 10; x++)
  21. Write_File("c:/lyshark.log", "hello lyshark\n");
  22. system("pause");
  23. return 0;
  24. }

获取文件总行数:

  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. int Get_File_Line(FILE *fp)
  4. {
  5. if (fp == NULL) return -1;
  6. char buffer[4096] = { 0 };
  7. int line = 0;
  8. while (fgets(buffer, 4096, fp) != NULL)
  9. ++line;
  10. // 恢复指针起始位置
  11. fseek(fp, 0, SEEK_SET);
  12. return line + 1;
  13. }
  14. int main(int argc, char* argv[])
  15. {
  16. FILE *fp = fopen("c:/lyshark.log", "r");
  17. int line = Get_File_Line(fp);
  18. printf("文件总行数: %d \n", line);
  19. system("pause");
  20. return 0;
  21. }

简易文件加解密: 第一次调用文件实现加密,第二次调用实现解密.

  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. int encrypt(char *src_file, char *dst_file, char *passwd)
  4. {
  5. FILE *fp_src = fopen(src_file, "rb");
  6. FILE *fp_dst = fopen(dst_file, "wb");
  7. if (fp_src == NULL || fp_dst == NULL)
  8. return - 1;
  9. char ch;
  10. while (!feof(fp_src))
  11. {
  12. ch = fgetc(fp_src);
  13. if (feof(fp_src))
  14. break;
  15. ch = ch ^ *(passwd);
  16. fputc(ch, fp_dst);
  17. }
  18. fclose(fp_src);
  19. fclose(fp_dst);
  20. return 1;
  21. }
  22. int main(int argc, char* argv[])
  23. {
  24. int encode_ret = encrypt("c:/lyshark.log", "c:/encode.log", "1233");
  25. if (encode_ret == 1)
  26. printf("加密完成 \n");
  27. int decode_ret = encrypt("c:/encode.log", "c:/decode.log", "1233");
  28. if (decode_ret == 1)
  29. printf("解密完成 \n");
  30. system("pause");
  31. return 0;
  32. }

实现格式化读写:

  1. #include <stdio.h>
  2. struct Student
  3. {
  4. int uid;
  5. char name[20];
  6. int age;
  7. };
  8. void write()
  9. {
  10. FILE *fp = fopen("c://ttt.log", "wt+");
  11. struct Student stu[3] = {
  12. {1001,"admin",22},
  13. {1002,"guest",33},
  14. {1003,"uroot",12},
  15. };
  16. // 将数据格式化输出到文本中保存
  17. for (int x = 0; x < 3; x++)
  18. fprintf(fp, "%d %s %d \n", stu[x].uid, stu[x].name, stu[x].age);
  19. fclose(fp);
  20. }
  21. void read()
  22. {
  23. struct Student stu;
  24. FILE *fp = fopen("c://ttt.log", "r");
  25. while (fscanf(fp,"%d %s %d \n",&stu.uid,&stu.name,&stu.age) != EOF)
  26. {
  27. printf("UID: %d --> Name: %s --> Age: %d \n", stu.uid,stu.name,stu.age);
  28. }
  29. /*
  30. while (fgets(buffer, 1024, fp) != NULL)
  31. {
  32. sscanf(buffer,"%d %s %d \n", stu.uid, stu.name, stu.age);
  33. index++;
  34. }
  35. */
  36. }
  37. int main(int argc, char* argv[])
  38. {
  39. write();
  40. read();
  41. system("pause");
  42. return 0;
  43. }

实现数组块读写:

  1. #define _CRT_SECURE_NO_WARNINGS
  2. #include <stdio.h>
  3. int main(int argc, char* argv[])
  4. {
  5. int Array[10] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
  6. // 将数组写入到文件中保存
  7. FILE *write = fopen("c://list.log", "wb");
  8. fwrite(Array, sizeof(int), 10, write);
  9. fclose(write);
  10. // 从文件中读取数组元素
  11. FILE *read = fopen("c://list.log", "rb");
  12. int NewArray[10] = { 0 };
  13. int index = 0;
  14. while (!feof(read))
  15. {
  16. fread(&NewArray[index], sizeof(int), 1, read);
  17. index++;
  18. }
  19. fclose(read);
  20. // 循环打印出数组元素
  21. for (int x = 0; x < 10; x++)
  22. printf("%d \n", NewArray[x]);
  23. system("pause");
  24. return 0;
  25. }

实现结构块读写: 在定义结构块的时候,不应使用指针变量,因为指正无法被转储到文件中.

  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. struct Student
  4. {
  5. int uid;
  6. char name[30];
  7. int age;
  8. };
  9. // 保存结构到文件中
  10. int Save_Struct(struct Student *ptr, int len)
  11. {
  12. FILE *fp = fopen("c:/save.json", "wb");
  13. if (fp == NULL)
  14. return -1;
  15. for (int x = 0; x < len; x++)
  16. {
  17. fwrite(&ptr[x], sizeof(struct Student), 1, fp);
  18. }
  19. fclose(fp);
  20. return 0;
  21. }
  22. // 从文件中加载结构
  23. int Load_Struct(struct Student *ptr)
  24. {
  25. FILE *fp = fopen("c:/save.json", "rb");
  26. if (fp == NULL)
  27. return -1;
  28. int index = 0;
  29. while (!feof(fp))
  30. {
  31. fread(&ptr[index], sizeof(struct Student), 1, fp);
  32. index++;
  33. }
  34. fclose(fp);
  35. return 0;
  36. }
  37. int main(int argc, char* argv[])
  38. {
  39. struct Student stu[3] = {
  40. { 1001, "admin", 22 },
  41. { 1002, "guest", 33 },
  42. { 1003, "root", 12 },
  43. };
  44. Save_Struct(&stu, 3); // 保存文件
  45. // 将输入读取到read_stu结构中
  46. struct Student read_stu[3];
  47. Load_Struct(&read_stu);
  48. for (int x = 0; x < 3; x++)
  49. printf("UID: %d --> Name: %s --> Age: %d \n", read_stu[x].uid, read_stu[x].name, read_stu[x].age);
  50. system("pause");
  51. return 0;
  52. }

实现结构随机读写:

  1. #include <stdio.h>
  2. struct Student
  3. {
  4. int uid;
  5. char name[20];
  6. int age;
  7. };
  8. int main(int argc, char* argv[])
  9. {
  10. struct Student stu[3] = {
  11. { 1001, "admin", 22 },
  12. { 1002, "guest", 33 },
  13. { 1003, "uroot", 12 },
  14. };
  15. FILE *fp = fopen("c://was.txt", "wb+");
  16. /*
  17. for (int x = 0; x < 3; x++)
  18. fprintf(fp, "%d %s %d \n", stu[x].uid, stu[x].name, stu[x].age);
  19. fclose(fp);
  20. */
  21. // 随机读写的方式
  22. fwrite(stu, sizeof(struct Student), 3, fp); // 写入三条数据
  23. fclose(fp);
  24. struct Student p;
  25. FILE *fp1 = fopen("c://was.txt", "rb+");
  26. fseek(fp, sizeof(struct Student), SEEK_SET); // 移动文件指针
  27. fread(&p, sizeof(struct Student), 1, fp1); // 读取数据
  28. printf("%d %s \n",p.uid,p.name); // 输出
  29. system("pause");
  30. return 0;
  31. }

简易vim

  1. #include <stdio.h>
  2. int main(int argc, char* argv[])
  3. {
  4. FILE * fp = fopen("c:/aaa.txt", "w");
  5. if (fp == NULL)
  6. return -1;
  7. char buf[1024];
  8. while (1)
  9. {
  10. memset(buf, 0, 1024);
  11. fgets(buf, 1024, stdin);
  12. if (strncmp("exit()", buf, 6) == 0)
  13. break;
  14. int index = 0;
  15. while (buf[index] != '\0')
  16. fputc(buf[index++], fp);
  17. }
  18. fclose(fp);
  19. system("pause");
  20. return 0;
  21. }

实现小文件拷贝:

  1. #include <stdio.h>
  2. int Copy_File(const char *src,const char *dst)
  3. {
  4. FILE *src_file = fopen(src, "rb");
  5. FILE *dst_file = fopen(dst, "wb");
  6. if (src_file == NULL || dst_file == NULL)
  7. return - 1;
  8. char buffer;
  9. while (fread(&buffer,sizeof(char),1,src_file) != 0)
  10. {
  11. fwrite(&buffer, sizeof(char), 1, dst_file);
  12. }
  13. fcloseall();
  14. return 1;
  15. }
  16. int main(int argc, char * argv[])
  17. {
  18. Copy_File("c:/lyshark.exe", "c:/www.exe");
  19. system("pause");
  20. return 0;
  21. }

实现大文件拷贝:

  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. int Copy_File(const char *src, const char *dst)
  4. {
  5. FILE *src_file = fopen(src, "rb");
  6. FILE *dst_file = fopen(dst, "wb");
  7. if (src_file == NULL || dst_file == NULL)
  8. return -1;
  9. char *buffer;
  10. buffer = (char *)malloc(sizeof(char)* 1024);
  11. memset(buffer, 0, 1024);
  12. while (fread(buffer, sizeof(char), 1024, src_file) != 0)
  13. {
  14. fwrite(buffer, sizeof(char), 1024, dst_file);
  15. memset(buffer, 0, 1024);
  16. }
  17. free(buffer);
  18. fcloseall();
  19. return 1;
  20. }
  21. int main(int argc, char * argv[])
  22. {
  23. Copy_File("c:/www.exe", "c:/gt.exe");
  24. system("pause");
  25. return 0;
  26. }

实现文件合并:

  1. #include <stdio.h>
  2. int Merge_File(const char *src, const char *dst)
  3. {
  4. FILE *src_file = fopen(src, "r");
  5. FILE *dst_file = fopen(dst, "a+");
  6. if (src_file == NULL || dst_file == NULL)
  7. return -1;
  8. char buffer;
  9. fseek(dst_file, 0, SEEK_END);
  10. buffer = fgetc(src_file);
  11. while (!feof(src_file))
  12. {
  13. fputc(buffer, dst_file);
  14. buffer = fgetc(src_file);
  15. }
  16. fcloseall();
  17. return 1;
  18. }
  19. int main(int argc, char * argv[])
  20. {
  21. Merge_File("c:/aaa.txt", "c:/bbb.txt");
  22. system("pause");
  23. return 0;
  24. }

实现统计文件大小:

  1. #include <stdio.h>
  2. int Get_File_Size(const char *file_name)
  3. {
  4. FILE *fp;
  5. long file_size;
  6. if (fp = fopen(file_name, "r"))
  7. {
  8. fseek(fp, 0, SEEK_END);
  9. file_size = ftell(fp);
  10. fcloseall();
  11. return file_size;
  12. }
  13. return 0;
  14. }
  15. int main(int argc, char * argv[])
  16. {
  17. long ret = Get_File_Size("c:/lyshark.exe");
  18. printf("文件大小是: %d 字节 \n", ret/1024);
  19. system("pause");
  20. return 0;
  21. }

大文件排序 001

  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <time.h>
  4. void Random()
  5. {
  6. srand((unsigned int)time(NULL));
  7. FILE *fp = fopen("c:/sp.txt", "w");
  8. if (!fp)
  9. return -1;
  10. for (int x = 0; x < 10000; x++)
  11. {
  12. fprintf(fp, "%d\n", rand() % 1000 + 1);
  13. }
  14. fcloseall();
  15. }
  16. int main(int argc, char * argv[])
  17. {
  18. FILE *fp = fopen("c:/sp.txt", "r");
  19. if (!fp)
  20. return -1;
  21. int *ptr = (int *)malloc(sizeof(int)* 10000);
  22. // 读取数据,并放入堆空间中.
  23. for (int x = 0; x < 10000; x++)
  24. fscanf(fp, "%d\n", &ptr[x]);
  25. for (int x = 0; x < 10000; x++)
  26. {
  27. for (int y = 0; y < 10000 - x - 1; y++)
  28. {
  29. if (ptr[y] > ptr[y + 1])
  30. {
  31. int tmp = ptr[y];
  32. ptr[y] = ptr[y + 1];
  33. ptr[y + 1] = tmp;
  34. }
  35. }
  36. }
  37. fcloseall();
  38. // 排序完成后,开始写入数据
  39. FILE *fp1 = fopen("c:/sp.txt", "w");
  40. if (!fp1)
  41. return -1;
  42. for (int x = 0; x < 10000; x++)
  43. fprintf(fp1, "%d\n", ptr[x]);
  44. fcloseall();
  45. free(ptr);
  46. system("pause");
  47. return 0;
  48. }

文件读写案例:

  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. // 配置文件数组
  4. struct ConfigInfo
  5. {
  6. char key[64];
  7. char val[128];
  8. };
  9. // 获得文件有效函数
  10. int get_line_config(FILE *file)
  11. {
  12. }
  13. // 加载配置文件
  14. void loadFile(const char *file_path,char **fileData,int len)
  15. {
  16. FILE *fp = fopen(file_path, "r");
  17. if (NULL == fp)
  18. return;
  19. // 按行读取
  20. int lines = get_line_config(fp); // 获取文件行数
  21. char **tmp = malloc(sizeof(char *)*lines); // 给每行开辟内存
  22. char buf[1024] = {0};
  23. int index = 0;
  24. while (fgets(buf,1024,fp) != NULL)
  25. {
  26. // 如果返回false 说明无效
  27. if (!isvalid_configFile(buf))
  28. {
  29. continue;
  30. }
  31. tmp[index++] = malloc(strlen(buf) + 1);
  32. strcpy(tmp[index++], buf);
  33. memset(buf, 0, 1024);
  34. }
  35. *fileData = tmp;
  36. *len = lines;
  37. }
  38. // 解析配置文件
  39. void parseFile_configfile(char **fileData, int len, struct ConfigInfo ** info)
  40. {
  41. }
  42. // 获取指定配置信息
  43. void getInfo_Config(struct ConfigInfo *info)
  44. {
  45. }
  46. // 判断行是否有效
  47. void isvalid_configFile()
  48. {
  49. }
  50. int main(int argc, char * argv[])
  51. {
  52. system("pause");
  53. return 0;
  54. }

获得文件有效行

  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. // 判断数据是否符合规则
  4. int isvald(const char *buf)
  5. {
  6. if (buf[0] == '#' || buf[0] == '\n' || strchr(buf, ':') == NULL)
  7. return 0;
  8. return 1;
  9. }
  10. // 获取有效行
  11. int get_line(FILE *fp)
  12. {
  13. char buffer[1024] = { 0 };
  14. int index = 0;
  15. while (fgets(buffer, 1024, fp) != NULL)
  16. {
  17. if (!isvald(buffer))
  18. continue;
  19. memset(buffer, 0, 1024);
  20. index++;
  21. }
  22. fseek(fp, 0, SEEK_SET);
  23. return index;
  24. }
  25. int main(int argc, char * argv[])
  26. {
  27. FILE *fp = fopen("c:/conf.ini","r");
  28. int line = get_line(fp); // 获取文件有效行
  29. printf("有效行: %d \n", line);
  30. system("pause");
  31. return 0;
  32. }
  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. // 配置文件数组
  4. struct ConfigInfo
  5. {
  6. char key[64];
  7. char val[128];
  8. };
  9. // 判断数据是否符合规则
  10. int isvald(const char *buf)
  11. {
  12. if (buf[0] == '#' || buf[0] == '\n' || strchr(buf, ':') == NULL)
  13. return 0;
  14. return 1;
  15. }
  16. // 获取有效行
  17. int get_line(FILE *fp)
  18. {
  19. char buffer[1024] = { 0 };
  20. int index = 0;
  21. while (fgets(buffer, 1024, fp) != NULL)
  22. {
  23. if (!isvald(buffer))
  24. continue;
  25. memset(buffer, 0, 1024);
  26. index++;
  27. }
  28. fseek(fp, 0, SEEK_SET);
  29. return index;
  30. }
  31. // 加载有效行,到内存栈地址
  32. void load(const char *path, char **data, int *len)
  33. {
  34. FILE *fp = fopen(path, "r");
  35. int line = get_line(fp); // 获取有效行
  36. char **tmp = malloc(sizeof(char *)* line); // 给每行开辟空间
  37. char buf[1024] = { 0 };
  38. int index = 0;
  39. while (fgets(buf,1024,fp) != NULL)
  40. {
  41. if (!isvald(buf))
  42. continue;
  43. tmp[index] = malloc(strlen(buf) + 1);
  44. strcpy(tmp[index], buf);
  45. memset(buf, 0, 1024);
  46. ++index;
  47. }
  48. *data = tmp;
  49. *len = line;
  50. fcloseall();
  51. }
  52. // 解析
  53. char * parser(char **data, int len, struct ConfigInfo **info,char *key)
  54. {
  55. struct ConfigInfo *my = malloc(sizeof(struct ConfigInfo) * len);
  56. memset(my, 0, sizeof(struct ConfigInfo) * len);
  57. for (int x = 0; x < len; x++)
  58. {
  59. char *pos = strchr(data[x], ':');
  60. strncpy(my[x].key, data[x], pos - data[x]); // 拷贝key
  61. strncpy(my[x].val, pos+1 , strlen(pos+1) -1); // 拷贝val
  62. printf("key: %s --> val: %s \n", my[x].key,my[x].val);
  63. if (strcmp(key, my[x].key) == 0)
  64. return my[x].val;
  65. }
  66. // 释放文件
  67. for (int y = 0; y < len; ++y)
  68. {
  69. if (data[y] != NULL)
  70. free(data[y]);
  71. }
  72. }
  73. int main(int argc, char * argv[])
  74. {
  75. char *filedata = NULL;
  76. struct ConfigInfo *info = NULL;
  77. int lines = 0;
  78. load("c:/conf.ini", &filedata, &lines);
  79. char * user = parser(filedata, lines, &info,"username");
  80. printf("username = %s", user);
  81. system("pause");
  82. return 0;
  83. }

文件读取问题版

  1. #include <stdio.h>
  2. #include <string.h>
  3. int main(int argc, char* argv[])
  4. {
  5. getchar();
  6. FILE *fp = fopen("c:/lyshark.log", "w");
  7. if (fp == NULL) return -1;
  8. char buffer[1024];
  9. while (1)
  10. {
  11. memset(buffer, 0, 1024);
  12. fgets(buffer, 1024, stdin);
  13. if (strcmp(buffer, "exit"))
  14. break;
  15. int index = 0;
  16. while (buffer[index] != '\0')
  17. fputc(buffer[index++],fp);
  18. }
  19. fclose(fp);
  20. system("pause");
  21. return 0;
  22. }

文件读取 新建一个文本,里面有几行数据,我们根据数组中的行数动态开辟内存空间,并且字符串长度是多长就分配多长的空间。

  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. // 获取文件的总行数
  4. int GetFileLine(FILE *fp)
  5. {
  6. if (fp == NULL) return -1;
  7. char buf[1024] = { 0 };
  8. int line = 0;
  9. while (fgets(buf,1024,fp) != NULL)
  10. {
  11. ++line;
  12. }
  13. // 恢复指针起始位置
  14. fseek(fp,0,SEEK_SET);
  15. return line;
  16. }
  17. int ReadFileData(FILE *fp,int line,char **pContent)
  18. {
  19. char buf[1024] = { 0 };
  20. int index = 0;
  21. while (fgets(buf, 1024, fp) != NULL)
  22. {
  23. int curLineLen = strlen(buf) + 1; // 获取每行数据长度
  24. //printf("读取到每行数据: %s", buf);
  25. // 给当前行分配内存
  26. char * lineContent = malloc(sizeof(char)* curLineLen);
  27. strcpy(lineContent, buf);
  28. pContent[index++] == lineContent;
  29. memset(buf, 0, 1024);
  30. }
  31. }
  32. void ShowFileContent(char **pContent, int line)
  33. {
  34. for (int i = 0; i < line; i++)
  35. {
  36. printf("%d %s", i, pContent[i]);
  37. }
  38. }
  39. int main(int argc, char* argv[])
  40. {
  41. FILE *fp = fopen("c:/Recovery.txt", "r");
  42. int line = GetFileLine(fp);
  43. // 分配的行数取决于文件行数
  44. char **pContent = malloc(sizeof(char*)* line);
  45. // 读取文件内容
  46. ReadFileData(fp, line, pContent);
  47. // 输出文件内容
  48. ShowFileContent(pContent, line);
  49. system("pause");
  50. return 0;
  51. }

C/C++ 文件与指针操作笔记的更多相关文章

  1. python之文件读写操作笔记

    对不同类的文件操作,需要调用相关的库文件,一般情况下,可以选择建立:写文件函数和读文件函数.在写文件与读文件函数中 我们可以采用:with  open('文件名','w', encoding='utf ...

  2. Py修行路 python基础 (七)文件操作 笔记(随时更改添加)

    文件操作流程: 1.打开文件 open() 2.操作文件 read .writeread(n) n对应读指定个数的 2.x中读取的是字节! 3.x中读取的是字符!read 往外读取文件,是以光标位置开 ...

  3. Linux学习笔记(三)目录和文件都能操作的命令

    目录和文件都能操作的命令 rm cp mv rm 英文原意:remove files or directories 功能:删除文件或目录 语法:rm 选项[-fir] 文件或目录 rm -f 强制删除 ...

  4. Python学习笔记--文件的相关操作

    文件的读取操作 读操作 实现: read()--读完 read(10)--读取10个字节 readline()--将所有行并到一行输出 readlines()--一次读取一行 文件的关闭: 实现: 上 ...

  5. C++中的智能指针、轻量级指针、强弱指针学习笔记

    一.智能指针学习总结 1.一个非const引用无法指向一个临时变量,但是const引用是可以的! 2.C++中的delete和C中的free()类似,delete NULL不会报"doubl ...

  6. PHP文件相关的操作函数——目录操作

    1.有关文件类型的函数 PHP是以UNIX的文件系统为模型的,因此在Windows系统中我们只能获得“file”.“dir”或者“unknown”三种文件类型.而在UNIX系统中,我们可以获得“blo ...

  7. 文件I/O操作(1)

    linux系统调用和用户编程接口(api) 系统调用是指在操作系统提供给用户程序调用的一组“特殊”的接口,用户程序可以通过这组特殊的接口来获取操作系统内核提供的服务,例如用户可以通过进程控制相关的系统 ...

  8. C和指针---读书笔记。

    C和指针---读书笔记.1,unsigned int  声明无符号int类型 默认是 singned,即此整数类型包括正负数.也可用于long上.说明符有 unsigned signed short ...

  9. 用C++进行简单的文件I/O操作-转自VC知识库

    原文请见 http://www.vckbase.com/index.php/wv/1158 序论 我曾发表过文件输入输出的文章,现在觉得有必要再写一点.文件 I/O 在C++中比烤蛋糕简单多了. 在这 ...

  10. linux中文件I/O操作(系统I/O)

    我们都知道linux下所有设备都是以文件存在的,所以当我们需要用到这些设备的时候,首先就需要打开它们,下面我们来详细了解一下文件I/O操作. 用到的文件I/O有以下几个操作:打开文件.读文件.写文件. ...

随机推荐

  1. 【每日一题】20.K-th Number (二分 + 尺取)

    关于此题,我们分析一下: 一个区间第k大的数不小于x的条件是什么? 答案就是一个区间内不小于x的数的个数不小于k 那么,我们就会发现,我们其实并不需要知道每个数的值,实际上对我们有用的只有每个数与x的 ...

  2. Codeforces Round #719 (Div. 3) A~E题解

    51鸽了几天,有几场比赛的题解还没发布,今天晚上会补上的 1520A. Do Not Be Distracted! 问题分析 模拟,如果存在已经出现的连续字母段则输出NO using ll = lon ...

  3. Codeforces Round #681 (Div. 2, based on VK Cup 2019-2020 - Final) 个人题解(A - D)

    1443A. Kids Seating 题意: 给你一个整数n,现在你需要从编号 \(1\) ~ $4 ⋅ n \(中选出\)n\(个编号使得这些编号之间\)g c d ≠ 1$ ,不能整除. 看了半 ...

  4. 图扑 HT for Web 风格属性手册教程

    图扑软件明星产品 HT for Web 是一套纯国产化独立自主研发的 2D 和 3D 图形界面可视化引擎.HT for Web(以下简称 HT)图元的样式由其 Style 属性控制,并且不同类型图元的 ...

  5. arguments使用

    arguments在函数中可以使用,表示包含了当前函数调用时传入的实参. arguments通过索引值获取实参,索引值从开始,按顺序依次表示函数调用时传过来的实参. 1 // arguments的使用 ...

  6. java进阶(32)--Collections工具类

    一.简介:Collection与Collections区别 1.Java.until.Collection是集合接口 2.Java.until.Collections是集合工具类,方便集合的操作 二. ...

  7. C++中不支持strdup(),使用_strdup()

    1.问题 C4996 'strdup': The POSIX name for this item is deprecated. Instead, use the ISO C and C++ conf ...

  8. 【面试题精讲】你了解String.intern方法吗

    有的时候博客内容会有变动,首发博客是最新的,其他博客地址可能会未同步,认准https://blog.zysicyj.top 首发博客地址 系列文章地址 String.intern 方法是 Java 中 ...

  9. [转帖]OceanBase实验4:迁移MySQL数据到OceanBase集群

    服务器环境 1)12核48G,操作系统为centos 7.9系统,单节点三副本1-1-1集群. 2)源MySQL数据库:与OceanBase同一台服务器,版本为MySQL 5.7. 1.使用 mysq ...

  10. [粘贴]Introducing Exadata X9M: Dramatically Faster, More Cost Effective, and Easier to Use

    https://blogs.oracle.com/exadata/post/exadata-x9m   The Exadata Product Management and Development t ...