总框架见（0. 总框架-CSDN博客）
（1）socket
(a)分配fd；(b)分配tcp控制块(tcb)
int socket(int domain, int type, int protocol);
AF_INET IPv4 Internet protocols ip(7)
AF_INET6 IPv6 Internet protocols ipv6(7)
AF_IPX IPX - Novell protocols
（2）bind
把fd和ip绑定到tcp控制块
int bind(int sockfd, const struct sockaddr *addr, socklen_t addrlen);（3）listen
开始监听fd
int listen(int sockfd, int backlog);（4）accept
(a)为客户端分配fd；(b)分配tcp控制块(tcb)
int accept(int sockfd, struct sockaddr *addr, socklen_t *addrlen);（5）recv
从内核copy数据到用户空间
ssize_t recv(int sockfd, void *buf, size_t len, int flags);（6）send
从用户空间copy数据到内核
ssize_t send(int sockfd, const void *buf, size_t len, int flags);（7）connect
connect客户端发送连接请求
int connect(int sockfd, const struct sockaddr *addr,
socklen_t addrlen);
（8）epoll_create
int epoll_create(int size);（9）epoll_ctl
int epoll_ctl(int epfd, int op, int fd, struct epoll_event *event);
EPOLL_CTL_ADD EPOLLIN EPOLLLT
EPOLL_CTL_MOD EPOLLOUT EPOLLET
EPOLL_CTL_DEL（10）epoll_wait
int epoll_wait(int epfd, struct epoll_event *events,
int maxevents, int timeout);（11）poll
int poll(struct pollfd *fds, nfds_t nfds, int timeout);（12）select
int select(int nfds, fd_set *readfds, fd_set *writefds,
fd_set *exceptfds, struct timeval *timeout);
void FD_CLR(int fd, fd_set *set);
int FD_ISSET(int fd, fd_set *set);
void FD_SET(int fd, fd_set *set);
void FD_ZERO(fd_set *set);
（13）read
ssize_t read(int fd, void *buf, size_t count);
参数说明
int fd
文件描述符，表示要读取的文件、管道、套接字或设备。
通常由系统调用（如 open()、socket() 等）返回。
void *buf
指向接收读取数据的缓冲区指针。
系统调用会将读取的数据写入到此缓冲区。
size_t count
要读取的最大字节数，指定缓冲区的大小。
返回值
成功时：
返回读取的字节数（可能小于请求的字节数 count）。
返回 0 表示已到达文件末尾（EOF）。
失败时：
返回 -1，并设置全局变量 errno 来指示错误原因（14）write
ssize_t write(int fd, const void *buf, size_t count);
参数说明
int fd
文件描述符，表示数据要写入的目标。
通常由 open() 或 socket() 等函数返回。
const void *buf
指向包含要写入数据的缓冲区的指针。
size_t count
指定要写入的字节数
返回值
成功时：
返回实际写入的字节数（可能小于请求的字节数 count）。
失败时：
返回 -1，并设置全局变量 errno 表示错误原因。（15）fork
创建的新进程，它是父进程的一个副本，几乎所有的数据（变量、文件描述符等）都会被复制。
返回值
父进程中：fork() 返回子进程的 PID（正整数）。
子进程中：fork() 返回 0。
出错时：返回 -1，同时设置 errno（16）perror
读取系统定义的全局变量 errno，然后通过查找对应的错误码输出一个与其相关联的错误消息
int main() {
int fd = open("nonexistent_file.txt", O_RDONLY);
if (fd == -1) {
perror("Error opening file");
}
return 0;
输出：
Error opening file: No such file or directory（17）strerror
如果需要获取错误描述并在代码中使用，而不是直接打印，可以使用 strerror(errno)。
#include <string.h>
printf("Error: %s\n", strerror(errno));
（18）atoi
是 C 标准库中用于将字符串转换为整数的函数。atoi 是 ASCII to Integer 的缩写。
int atoi(const char *str);
参数
str
指向需要转换的字符串（应以空字符 \0 结束）。
返回值
如果字符串可以成功解析为整数，则返回该整数值。
如果字符串不包含有效的数字，则返回值可能为 0（不安全，推荐使用 strtol 替代）。
int main() {
char str1[] = " -456";
char str2[] = "+789";
printf("Converted number 1: %d\n", atoi(str1));
// Output: -456
printf("Converted number 2: %d\n", atoi(str2));
// Output: 789
return 0;
}（19）strcmp
是 C 标准库中的一个函数，用于比较两个字符串的大小（基于字典序）。
int strcmp(const char *str1, const char *str2);
参数解释
str1
指向第一个字符串的指针。
str2
指向第二个字符串的指针
返回值
小于 0
如果 str1 的字典序小于 str2。
等于 0
如果 str1 和 str2 内容完全相同。
大于 0
如果 str1 的字典序大于 str2
int main() {
char str1[] = "apple";
char str2[] = "banana";
int result = strcmp(str1, str2);
printf("Result: %d\n", result);
// Output: Result: negative value (e.g., -1)
return 0;
}
（20）memset
是 C 标准库中的一个函数，主要用于对一块内存区域进行初始化或设置。
void *memset(void *s, int c, size_t n);
参数说明
void *s
指向要初始化的内存区域的起始地址。
int c
用于设置的值，会被解释为一个 unsigned char（0 到 255），然后复制到内存区域。
size_t n
要设置的字节数。
返回值
返回指向内存区域 s 的指针。
功能
将指定的值填充到连续的内存区域中。
常用于数组或结构体的初始化。
常见用途
功能1：初始化数组
使用 memset 将数组清零或设置为某个默认值。
int arr[10];
memset(arr, 0, sizeof(arr)); // 初始化为 0
功能2：清空结构体中的所有成员变量。
struct Data {
int a;
char b[20];
} data;
memset(&data, 0, sizeof(data)); // 将结构体清零
（21）memcpy
是 C 标准库中的一个函数，将内存块中的数据从一个位置复制到另一个位置。
void *memcpy(void *dest, const void *src, size_t n);
参数说明
void *dest
目标内存地址，表示复制数据的目的地。
const void *src
源内存地址，表示复制数据的来源。
size_t n
要复制的字节数。
返回值
返回目标内存地址 (dest) 的指针。
基本用法
int main() {
char src[] = "Hello, World!";
char dest[20];
memcpy(dest, src, strlen(src) + 1);
// 复制 src 到 dest
printf("Source: %s\n", src);
printf("Destination: %s\n", dest);
return 0;
}
输出：
Source: Hello, World!
Destination: Hello, World!
int main() {
int src[5] = {1, 2, 3, 4, 5};
int dest[5];
memcpy(dest, src, 5 * sizeof(int)); // 复制 5 个整型值
for (int i = 0; i < 5; i++) {
printf("dest[%d] = %d\n", i, dest[i]);
}
return 0;
}
输出：
dest[0] = 1
dest[1] = 2
dest[2] = 3
dest[3] = 4
dest[4] = 5
应用场景
字符串操作：复制字符串的原始字节数据（与 strcpy 的主要区别是 memcpy 可以复制非空终止的二进制数据）。
数组复制：处理任意类型的数组，例如 int 或 float。
内存初始化：与 memset 配合使用，分配和初始化内存。
结构体复制：在需要字节级拷贝时，处理复杂结构体数据。（22）strncpy
复制字符串的指定长度
char *strncpy(char *dest, const char *src, size_t n);
参数说明
char *dest
目标字符数组的指针，复制后的字符串将存储在这里。
const char *src
源字符串的指针，要被复制的字符串内容。
size_t n
要复制的最大字符数。如果 src 长度小于 n，则目标字符串会填充空字符（\0）；如果 src 长度大于或等于 n，则目标字符串不会被空字符终止。
返回值
返回 dest 指针，即目标字符串的指针。
功能
将源字符串 src 复制到目标字符数组 dest 中，最多复制 n 个字符。
如果源字符串长度小于 n，strncpy 会用空字符（\0）填充目标字符串的剩余部分；如果源字符串长度大于或等于 n，目标字符串没有终止符（\0）。
与 strcpy 的对比
strcpy：直接复制整个字符串，直到遇到终止符 \0。无法防止溢出。
例如：strcpy(dest, src);
strncpy：复制指定数量的字符，并会根据情况使用终止符 \0 填充目标字符串。
更安全，因为可以限制复制的字符数，防止溢出
int main() {
char src[] = "Hello, World!";
char dest[20];
// 将最多 10 个字符从 src 复制到 dest
strncpy(dest, src, 10);
dest[10] = '\0'; // 确保终止符
printf("Copied string: %s\n", dest);
// 输出: Hello, Wo
return 0;
}
代码解析
strncpy(dest, src, 10);：最多复制 10 个字符。
然后手动添加终止符 dest[10] = '\0';，这是因为源字符串可能没有包含终止符（在字符串更长的情况下）。
结果是 dest 中的内容为 "Hello, Wo"，因为 src 前 10 个字符被复制。
（23）strlen
size_t strlen(const char *str);
功能
strlen 用于计算字符串的长度（不包括终止符 \0）。
它会遍历字符串直到遇到第一个空字符 \0 为止，并返回已遍历的字符数。
参数说明
const char *str
指向以空字符 \0 结尾的字符串。
返回值
返回字符串的长度（不包括终止符 \0）的大小，以 size_t 类型表示。
int main() {
char str[] = "Hello, World!";
size_t length = strlen(str);
printf("The length of the string is: %zu\n", length);
// 输出: 13
return 0;
}
代码解析
字符串 str[]:
包含 "Hello, World!"，长度为 13（不包括终止符 \0）。
strlen(str):
遍历字符串，直到遇到终止符 \0。
计算字符数：'H', 'e', 'l', 'l', 'o', ',', ' ', 'W', 'o', 'r', 'l', 'd', '!'。
返回值:
返回 13，表示字符串的长度
与 sizeof 的对比
strlen运行时计算字符串长度。适用于动态字符串。不包括终止符 \0。
sizeof编译时计算数组大小（字节数）。适用于固定大小的字符数组。包括终止符 \0 的大小。
示例：
char str1[] = "Hello";
char *str2 = "Hello";
printf("strlen(str1): %zu\n", strlen(str1)); // 输出 5
printf("sizeof(str1): %zu\n", sizeof(str1)); // 输出 6
printf("strlen(str2): %zu\n", strlen(str2)); // 输出 5
printf("sizeof(str2): %zu\n", sizeof(str2)); // 输出 8 (指针大小)
（24）snprint
用于将格式化的数据写入字符串，并确保不会溢出字符串缓冲区。它是 sprintf 的更安全版本，避免了可能的缓冲区溢出问题。
int snprintf(char *str, size_t size, const char *format, ...);
参数说明
char *str
指向要写入格式化输出的字符数组。
size_t size
指定目标字符串的最大大小，包括结尾的 '\0'（空字符）。snprintf 确保总输出长度不超过这个值。
const char *format
格式化字符串，与 printf 的格式化字符串类似，例如 %d, %s, %f 等。
... (可变参数)
需要插入到格式化字符串中的数据
返回值
返回写入的字符数，不包括终止的 \0 字符：
如果 size 足够大，返回值是实际写入的字符数。
如果 size 不够大，返回值是本应该写入的字符数（截断的字符串长度）。
缓冲区不足的情况
int main() {
char buffer[10];
int num = 123456;
int written = snprintf(buffer, sizeof(buffer), "Number: %d", num);
printf("Formatted string: %s\n", buffer); // 输出截断的内容
printf("Characters written: %d\n", written); // 返回未截断的实际字符数
return 0;
}
输出：
Formatted string: Number: 1
Characters written: 12
说明：
缓冲区 buffer 长度为 10，无法容纳完整字符串 "Number: 123456"。
结果字符串被截断为 "Number: 1"，但 snprintf 的返回值是实际所需的字符数 12（25）malloc
堆上分配内存，并返回指向分配内存块的指针。
void *malloc(size_t size);
参数说明
size
请求分配的内存大小（以字节为单位）。size 必须大于 0。
返回值
返回分配的内存的起始地址，类型是 void*，即通用指针。
如果内存分配失败（比如系统没有足够的内存），malloc 返回 NULL。
特性
动态内存分配
malloc 函数从程序的堆内存区域（Heap）分配指定大小的内存。在堆上分配的内存空间不会随着函数调用结束而销毁，必须通过 free 显式释放。
基本用法
int main() {
int *arr = (int *)malloc(5 * sizeof(int)); // 动态分配 5 个整数的空间
if (arr == NULL) {
printf("Memory allocation failed!\n");
return 1;
}
for (int i = 0; i < 5; i++) {
arr[i] = i + 1;
printf("%d ", arr[i]);
}
printf("\n");
free(arr); // 释放内存
return 0;
}
输出：
1 2 3 4 5（26）free
用于释放由动态内存分配函数（如 malloc、calloc 或 realloc）分配的内存。将之前分配的动态内存归还给操作系统或内存管理器。释放后，该内存块可以被再次分配和使用。
void free(void *ptr);
参数说明
void *ptr
动态分配的内存块的指针，该指针通常是通过 malloc、calloc 或 realloc 返回的。
如果 ptr 是 NULL，free 不会进行任何操作。
基本用法
int main() {
int *arr = (int *)malloc(5 * sizeof(int)); // 动态分配 5 个整数的空间
if (arr == NULL) {
perror("malloc failed");
return 1;
}
for (int i = 0; i < 5; i++) {
arr[i] = i + 1;
printf("%d ", arr[i]);
}
printf("\n");
free(arr); // 释放内存
arr = NULL; // 避免悬空指针
return 0;
}
输出：
1 2 3 4 5
常见问题
1. 为什么释放未分配的内存是危险的？
如果尝试 free 一个未分配的指针，可能会导致程序崩溃或者未定义行为，因为内存管理器试图释放一个它没有跟踪的内存区域。
2. 为什么要将指针置为 NULL？
避免悬空指针（Dangling Pointer）。
悬空指针是指指向已释放内存区域的指针，如果不小心使用它（如读写操作），可能会导致不可预测的错误。
3. 始终配对 malloc 和 free，避免内存泄漏和悬空指针。
