文件I/O学习笔记

// 从src.txt拷贝到dest.txt，带完整错误处理
FILE *fp = fopen("src.txt", "r");
if (!fp) { perror("打开失败"); return -1; }

int ch;
while ((ch = fgetc(fp)) != EOF) {
    fputc(ch, dest_fp);
}

if (ferror(fp)) { // 检查是否因读取错误而退出循环
    perror("读取错误");
} else if (feof(fp)) { // 检查是否因读到文件末尾而退出
    printf("成功拷贝\n");
}
fclose(fp);

FILE *fp1 = fopen(argv[1], "r");
FILE *fp2 = fopen(argv[2], "w");

char buf[10]; // 缓冲区
while (fgets(buf, 10, fp1) != NULL) {
    // fgets一次最多读sizeof(buf)-1个字符，即9个
    // 如果一行超过9个字符，它会分多次读取
    fputs(buf, fp2);
}

// fgets返回NULL时，同样需要用feof和ferror检查
if(feof(fp1)) printf("拷贝完毕!\n");
else if(ferror(fp1)) perror("读取错误");

fclose(fp1); fclose(fp2);

// 1. 只读打开源文件、只写目标文件（若不存在则创建，若存在则清空）
FILE *fp1 = fopen(file1.txt, "r");
FILE *fp2 = fopen(file2.txt, "w");

// 2. 循环读取源文件并放入目标文件
char *buf = calloc(5, 20);  // 分配了100字节
while (1) {
    fseek(fp1, 0, SEEK_END); // 将文件指针移到文件末尾
  	long file_size = ftell(fp1);  // 获取当前文件指针位置，即文件大小
  	fseek(fp1, 0, SEEK_SET); // 将文件指针移回文件开头，以便后续读取

    // fread返回的是整数块，不足一整块的不会被计入n
    // 但是是可以被正常读取
    // 例如读到96个字节，返回4，读到46个字节，返回2，读到16个字节，返回0
    int n = fread(buf, 20, 5, fp1);  // 用buf缓冲区，读分配fp1指向文件的20字节*5块
    if (n < 5) { // a. 读取失败或到文件尾
        if (feof(fp1)) {
            long b = ftell(fp1); // 将剩余的 0-99 个字节拷贝到目标文件
            fwrite(buf, b - a, 1, fp2);
            break;
        }
    }
    fwrite(buf, 20, 5, fp2); // b. 正常读到100个字节，写入目标文件
}

// 3. 释放资源
fclose(fp1); fclose(fp2);

FILE *fp1 = fopen(argv[1], "r");
FILE *fp2 = fopen(argv[2], "w");

int a; char buf[20]; float f;
// fscanf返回成功匹配并赋值的项数
while (fscanf(fp1, "%d %s %f", &a, buf, &f) == 3) {
    fprintf(fp2, "INT: %d, STR: %s, FLOAT: %.2f\n\n", a, buf, f);
}

fclose(fp1);  fclose(fp2);

char buf[100];
// 安全地将格式化数据写入字符串
snprintf(buf, sizeof(buf), "%d %s,%f data ...", 100, "hello", 3.14);

// 从字符串中解析数据
int a; char s[20]; float f;
sscanf(buf, "%d %s。%f", &a, s, &f);

printf("a: %d, s: %s, f: %f\n", a, s, f);
// 解析结果为：
// a: 100
// s: hello。3.140000
// f: 0.000000
// 因为“%s”后面加上字符后,hello和3.14会被连着读

FILE *fp = fopen(file.txt, "rb");

// 1. 将指针移动到文件末尾
if (fseek(fp, 0, SEEK_END) != 0) {
    perror("无法读到文件末尾");
    fclose(fp); return 1;
}

// 2. 获取当前位置，即文件大小
long file_size = ftell(fp);
if (file_size == -1L) {
    perror("ftell");
    fclose(fp);
    return 1;
}
printf("文件： '%s' 大小: %ld bytes\n", file.txt, file_size);
rewind(fp);// 3. 将指针移回文件开头，以便后续读取

fclose(fp);

fprintf(stdout, "abcd");  // 标准输出模式，默认放入缓冲区
fprintf(stderr, "1234");  // 标准错误模式，默认直接输出

FILE *fp = fopen("test.txt", "w+");  // 默认先放进缓冲区，所以不会立即放入文件

fprintf(fp, "1234");  // 默认放入缓冲区
char buf[100];
setvbuf(fp, buf, _IOLBF, 100);  // 设置缓冲区，_IOLBF表示行缓冲
fprintf(fp, "abcd\n");  // 修改为了行缓冲，且数据有换行符，立即放入文件
abort();  // 此时虽然程序也被强制中断，但数据已经保存到文件中，数据不丢失

int fd = open("non_existent_file.txt", O_RDONLY);
if (fd == -1) {
    // 方法一：使用 perror (推荐)
    // 输出: 打开文件失败: No such file or directory
    perror("打开文件失败");

    // 方法二：使用 strerror (更灵活)
    // 输出: Error opening file: No such file or directory
    printf("打开文件失败: %s\n", strerror(errno));

    return 1;
}

// 场景1: 读写方式打开，不存在则创建，权限为 rw-r--r--
int fd1 = open("log.txt", O_RDWR | O_CREAT | O_TRUNC, 0644);
if (fd1 == -1) { perror("open log.txt failed"); return 1; }
printf("文件已创建: %d\n", fd1);
close(fd1);

// 场景2: 安全地创建文件，如果文件已存在则失败
int fd2 = open("lock.file", O_WRONLY | O_CREAT | O_EXCL, 0600);
if (fd2 == -1) { perror("无法创建文件，可能文件已存在"); return 1; }
printf("文件已创建: %d\n", fd2);
close(fd2);

int fd = open("file.txt", O_RDONLY);

// 将指针移动到文件末尾，lseek返回值即为文件大小
off_t file_size = lseek(fd, 0, SEEK_END);
printf("文件'%s' 大小为 %ld bytes.\n", argv[1], file_size);

close(fd);

int fd = open("file.txt", O_RDWR | O_CREAT | O_TRUNC, 0644);
write(fd, "start", 5);
// 从当前位置向后移动1MB，形成空洞
lseek(fd, 1024 * 1024, SEEK_CUR);
write(fd, "end", 3);
close(fd);
// 使用 `ls -lh` 和 `du -h` 命令查看文件大小和实际占用空间的区别

int log_fd = open("file.txt", O_WRONLY | O_CREAT | O_TRUNC, 0644);

// 将标准输出(fd=1)重定向到log_fd
if (dup2(log_fd, STDOUT_FILENO) == -1) { perror("dup2"); return 1; }

close(log_fd); // 原log_fd可关闭，fd=1已指向日志文件

printf("这句话会输出到文件里.\n");
fprintf(stderr, "这句话将直接输出到终端\n");

int fd = STDIN_FILENO; // 用标准输入做演示

// 1. 获取当前状态标志
long flags = fcntl(fd, F_GETFL);
if (flags == -1) { perror("获取标准输入状态失败"); return 1; }

// 2. 添加非阻塞标志
flags |= O_NONBLOCK;

// 3. 应用新标志
if (fcntl(fd, F_SETFL, flags) == -1) { perror("设置标准输入状态失败"); return 1; }

char buf[10];
ssize_t n = read(fd, buf, sizeof(buf));
if (n < 0) {
    // 非阻塞read在无数据时立即返回-1
    // 因为理论上应该从用户输入读取数据，但用户没输入就直接开始读取数据，所以这里出错
    perror("在以非阻塞模式读取");
} else {
    printf("读取了 %ld bytes.\n", n);
}

int fd = open("mmap_test.txt", O_RDWR | O_CREAT, 0644);
ftruncate(fd, 100); // 确保文件至少有100字节
char *mapped_mem = mmap(NULL, 100, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
if (mapped_mem == MAP_FAILED) { perror("内存映射失败"); close(fd); return 1; }
close(fd); // mmap后可以立即关闭fd，映射关系依然存在
strcpy(mapped_mem, "你好内存映射，像操作内存一样操作文件,复制这段话到文件");
munmap(mapped_mem, 100); // 操作完成，解除映射

struct stat {
    dev_t     st_dev;     /* 存放该文件的设备 ID（device ID） */
    ino_t     st_ino;     /* inode 编号（Inode number） */
    mode_t    st_mode;    /* 文件类型和权限模式（file type & mode/permissions） */
    nlink_t   st_nlink;   /* 硬链接数量（number of hard links） */
    uid_t     st_uid;     /* 文件所有者的用户 ID（user ID of owner） */
    gid_t     st_gid;     /* 文件所有者的组 ID（group ID of owner） */
    dev_t     st_rdev;    /* 设备 ID（device ID，特殊文件才有） */
    off_t     st_size;    /* 文件总大小（total size, in bytes） */
    blksize_t st_blksize; /* 文件系统 I/O 的建议块大小（block size for filesystem I/O） */
    blkcnt_t  st_blocks;  /* 实际分配的 512 字节块数量（number of 512B blocks allocated） */
    struct timespec st_atim;  /* 最后一次访问时间（time of last access） */
    struct timespec st_mtim;  /* 最后一次修改时间（time of last modification） */
    struct timespec st_ctim;  /* 最后一次状态变化时间（time of last status change） */
};

struct stat st;//申请一个空间存文件信息
bzero(&st,sizeof(st));//清空文件信息表
stat("a.txt", &st);//读取文件信息

#include <grp.h>  // 用于 获取组信息 get by grope id
#include <pwd.h>  // 用于 获取用户信息 get password file entry by user ID
#include <stdio.h>
#include <sys/stat.h>
#include <sys/sysmacros.h>  // 用于 major 和 minor 宏
#include <time.h>
#include <unistd.h>
#include <fcntl.h>

// 辅助函数：解析文件类型
char get_file_type(mode_t mode) {
  if (S_ISREG(mode)) return '-';
  if (S_ISDIR(mode)) return 'd';
  if (S_ISLNK(mode)) return 'l';
  if (S_ISCHR(mode)) return 'c';
  if (S_ISBLK(mode)) return 'b';
  if (S_ISFIFO(mode)) return 'p';
  if (S_ISSOCK(mode)) return 's';
  return '?';
}

// 辅助函数：解析权限
void get_permissions(mode_t mode, char *str) {
  str[0] = (mode & S_IRUSR) ? 'r' : '-';
  str[1] = (mode & S_IWUSR) ? 'w' : '-';
  str[2] = (mode & S_IXUSR) ? 'x' : '-';
  str[3] = (mode & S_IRGRP) ? 'r' : '-';
  str[4] = (mode & S_IWGRP) ? 'w' : '-';
  str[5] = (mode & S_IXGRP) ? 'x' : '-';
  str[6] = (mode & S_IROTH) ? 'r' : '-';
  str[7] = (mode & S_IWOTH) ? 'w' : '-';
  str[8] = (mode & S_IXOTH) ? 'x' : '-';
  str[9] = '\0';
}

int main(int argc, char const *argv[]) {
  if (argc != 2) {
    fprintf(stderr, "使用方法: %s <文件或路径参数>\n", argv[0]);
    return 1;
  }

  struct stat st;
  if (lstat(argv[1], &st) == -1) {
    perror("lstat failed");
    return 1;
  }

  // 1. 打印文件类型和权限
  char perms[10];
  get_permissions(st.st_mode, perms);
  printf("%c%s ", get_file_type(st.st_mode), perms);

  // 2. 打印硬链接数
  printf("%ld ", st.st_nlink);

  // 3. 打印所有者和所属组
  printf("%s %s ", getpwuid(st.st_uid)->pw_name, getgrgid(st.st_gid)->gr_name);

  // 4. 关键：区分普通文件和设备文件
  if (S_ISCHR(st.st_mode) || S_ISBLK(st.st_mode)) {
    // 如果是设备文件，打印主、次设备号
    printf("%u, %-4u ", major(st.st_rdev), minor(st.st_rdev));
  } else {
    // 如果是普通文件，打印大小
    printf("%8ld ", st.st_size);
  }

  // 5. 打印最后修改时间
  char time_buf[20];
  strftime(time_buf, sizeof(time_buf), "%b %d %H:%M", localtime(&st.st_mtime));
  printf("%s ", time_buf);

  // 6. 打印文件名
  printf("%s\n", argv[1]);

  return 0;
}

#include <stdio.h>
#include <dirent.h>
#include <sys/stat.h>
#include <unistd.h>
#include <stdlib.h>
#include <string.h>

int main(int argc, char const *argv[]) {
    const char *dirpath = (argc > 1) ? argv[1] : ".";

    DIR *dp = opendir(dirpath);
    if (dp == NULL) {
        perror("opendir failed");
        return 1;
    }

    // *** 关键技巧：改变当前工作目录 ***
    if (chdir(dirpath) == -1) {
        perror("chdir failed");
        closedir(dp);
        return 1;
    }

    printf("Content of directory '%s':\n", dirpath);
    struct dirent *entry;
    struct stat st;

    // 循环读取目录中的每一个条目
    while ((entry = readdir(dp)) != NULL) {
        // 跳过隐藏文件 "." 和 ".."
        if (strcmp(entry->d_name, ".") == 0 || strcmp(entry->d_name, "..") == 0) {
            continue;
        }

        // 因为已经chdir，所以可以直接对文件名stat
        if (lstat(entry->d_name, &st) == -1) {
            perror(entry->d_name); // 如果stat失败，打印文件名和错误
            continue;
        }

        printf("%-20s \t Size: %ld bytes\n", entry->d_name, st.st_size);
    }

    closedir(dp);

    // 好的编程习惯是返回到原来的目录，但这非必需
    // chdir("..");

    return 0;
}

#include <sys/stat.h>
#include <sys/types.h>
#include <stdio.h>
#include <unistd.h>

int main() {
    const char *dir_name = "my_new_dir";

    // 创建目录，权限为 rwxr-xr-x
    if (mkdir(dir_name, 0755) == -1) {
        perror("mkdir failed");
        return 1;
    }
    printf("目录 '%s' 创建成功\n", dir_name);

    // ... 可以在这里做一些操作 ...

    // 删除目录
    if (rmdir(dir_name) == -1) {
        perror("删除失败");
        return 1;
    }
    printf("文件夹 '%s' 删除成功\n", dir_name);

    return 0;
}