Linux系统下C语言中的标准IO总结

#include <stdio.h>

int main()
{
	// 打开或者创建一个文件，使用 FILE 对象与该文件进行绑定。
	// 也常把 fp 叫为 文件流
	FILE* fp = fopen("example.txt", "a");
	// ...
}

#include <iostream>
#include <cstring>

int main() {

    const char* charString = "你好，世界！";
    std::cout << "Length of charString: " << std::strlen(charString) << std::endl;

    const char* multibyteString = u8"你好，世界！";  // UTF-8编码的多字节字符串
    std::cout << "Length of multibyteString: " << std::strlen(multibyteString) << std::endl;

    const wchar_t* wideString = L"你好，世界！";  // UTF-16编码的宽字符字符串
    std::wcout << L"Length of wideString: " << std::wcslen(wideString) << std::endl;
    return 0;
}

/*
运行结果为：
Length of charString: 18
Length of multibyteString: 18
Length of wideString: 6
*/

#include <stdio.h>

/*
pathname参数表示打开的文件路径名；
type参数指定对文件流的读、写方式。
若打开出错，返回 NULL。
*/
FILE* fopen(const char* pathname, const char* type);

FILE* freopen(const char* pathname, const char* type, FILE* fp);

FILE* fdopen(int fd, const char* type);

#include <stdio.h>

/*
若成功，返回0；若出错，返回 EOF
*/
int fclose(FILE* fp);

#include <stdio.h>

void setbuf(FILE* fp, char* buf);

/*
	buf参数为指定缓冲区，mode表示缓冲类型，size指定了缓冲的大小。
	成功返回0；出错返回非0。
*/
void setvbuf(FILE* fp, char* buf, int mode, size_t size);

void setbuffer(FILE* fp, char* buf, size_t size);

#include <stdio.h>
int getc(FILE* fp);
int fgetc(FILE* fp);
int getchar(void);
/*
以上三个函数，成功返回读取的字符，返回前将 unsigned char 类型转换为 int 类型；若已到达文件尾端或出错，返回 EOF。
*/

#include <stdio.h>
/* 检查 fp 指定的流是否发生了错误。若为真，则返回非0；否则，返回0 */
int ferror(FILE* fp);
/* 检查 fp 指定的流是否到达文件尾。若为真，则返回非0；否则，返回0 */
int feof(FILE* fp);
/* 清楚上述两个标志 */
void clearerr(FILE* fp);

#include <stdio.h>
int putc(int c, FILE* fp);
int fputc(int c,  FILE* fp);
// putchar(c) 等价于 putc(c, stdout);
int putchar(int c);
/*
以上三个函数，成功，返回c；若出错，返回EOF。
*/

FILE* fp = fopen("example.txt", "a+");
int c;
while ((c = fgetc(fp)) != EOF) {
	printf("%c", (unsigned char)c);
}
fclose(fp); 
/*
输出为：python
*/

FILE* fp = fopen("example.txt", "a+");
char buf[7] = "golang";
for (int i = 0; i < 6; ++i) {
	fputc(buf[i], fp);
}
fclose(fp);  
/*
文件中的内容为：pythongolang
*/

#include <stdio.h>
// n 为指定的缓冲区大小
// 将 fp 文件中的内容写入 buf 中，直至遇到换行符或者buf写满。
char* fgets(char* buf, int n, FILE* fp);
// gets 从标准输入进行读
char* gets(char* buf);
/*
以上两个函数，若成功，返回buf；若已达到文件末尾或出错，返回NULL。
*/

#include <stdio.h>
// fputs 不会将换行符写入到文件流中
int fputs(const char* str, FILE* fp);
// puts 将字符串输出到标准输出，会将换行符作为输出。
int puts(const char* str);
/*
以上两个函数，若成功，返回非负责；若出错，返回 EOF。
*/

#include <stdio.h>
// 若出错或到达文件末尾，返回值可以小于 nobj；需要调用 ferror 或 feof 来判断是哪一种情况。
size_t fread(void* ptr, size_t size, size_t nobj, FILE* fp);
// 若出错，返回值小于 nobj
size_t fwrite(const void* ptr, size_t size, size_t nobj, FILE* fp);
/*
以上两个函数，返回读写的对象数量。
ptr 指向待写入的对象
size 表示对象的大小
nobj 表示写入的对象数量
*/

char buffer[16] = "python";
FILE* wfp = fopen("test2.txt", "w");
fwrite(buffer, 1, strlen(buffer), wfp);
fclose(wfp);
printf("%s\n", buffer);
char buffer2[16];
FILE *rfp = fopen("test2.txt", "r");
fread(buffer2, 1, strlen(buffer), rfp);
fclose(rfp);
printf("%s\n", buffer2);

void test1()
{
    Person p1("Jack", 25);
    FILE* wfp = fopen("Person", "wb");
    fwrite((void*)&p1, sizeof(Person), 1, wfp);
    fclose(wfp);
    Person* p2 = new Person("Lisa", 19);
    std::cout << p2->name() << std::endl;
    FILE* rfp = fopen("Person", "rb");
    fread(p2, sizeof(Person), 1, rfp);
    fclose(rfp);
    std::cout << p2->name() << std::endl;
    // delete p2;   /* 若在这行执行此语句，出现 Segmentation fault */
    Person p3;
    FILE* rfp2 = fopen("Person", "rb+");
    fread(&p3, sizeof(Person), 1, rfp2);
    fclose(rfp2);
    std::cout << p3.name() << std::endl;
    /* 程序结束，Segmentation fault */
}

#include <stdio.h>
int printf(const char* format, ...);
int fprintf(FILE* fp, const char* format, ...);
/*
以上两个函数，成功，返回输出的字符数；出错，返回复制。
format 表示格式化字符串；
... 为C语言的可变参数，需要与 format 中的格式化进行匹配。
*/