简介
-
标准头文件
Linux POSIX 详解
<stdlib.h> 是 POSIX（可移植操作系统接口）规范中针对类 Unix 操作系统的 C 标准库中的一个头文件。它提供了一些标准函数、类型和宏，用于内存分配、转换、随机数生成等各种操作。
以下是 <stdlib.h> 中常用的一些函数和类型的概述：
内存分配与管理：
malloc(): 分配一块内存。calloc(): 分配一块内存并将其初始化为零。realloc(): 调整之前分配的内存块的大小。free(): 释放之前分配的内存块。
字符串转换：
atoi(),atol(),atoll(): 将字符串转换为整数。atof(): 将字符串转换为浮点数。itoa(): 将整数转换为字符串（不是标准 C 的一部分，但在某些实现中可用）。
伪随机数生成：
rand(): 生成伪随机整数。srand(): 种子初始化随机数生成器。
环境：
getenv(): 获取环境变量的值。system(): 执行 shell 命令。
实用函数：
exit(): 终止程序执行。abort(): 中止程序执行。qsort(): 对数组进行排序。bsearch(): 在排序数组中执行二分查找。
其他常量和类型：
EXIT_SUCCESS,EXIT_FAILURE: 标准的退出状态码。NULL: 空指针常量。size_t: 用于对象大小的无符号整数类型。
需要注意的是，<stdlib.h> 中的这些功能是 C 的标准功能，在不同的实现中可能会有系统特定的变化或扩展。此外，POSIX 的兼容性确保了这些函数和宏在各种类 Unix 系统中都是可用的。
要使用这些函数，需要在 C 程序的开头包含 <stdlib.h>，以便访问其定义和原型。
Linux POSIX malloc() 详解
在 Linux POSIX 中的 <stdlib.h> 头文件中，malloc() 函数是用于动态内存分配的关键函数之一。它允许程序在运行时请求分配一块指定大小的内存空间，并返回一个指向分配内存的指针。
函数签名：
1
void *malloc(size_t size);
参数：
size_t size: 要分配的内存块的大小（以字节为单位）。
返回值：
malloc()返回一个指向分配内存的指针。如果分配失败，则返回NULL。
功能：
malloc()用于动态地分配内存。它在堆上分配一块指定大小的连续内存块，并返回一个指向此内存块的指针。
使用示例：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
#include <stdio.h>
#include <stdlib.h>
int main() {
int *ptr;
int size = 5;
// 分配一个包含5个整数的内存块
ptr = (int *)malloc(size * sizeof(int));
if (ptr == NULL) {
printf("内存分配失败！\n");
exit(EXIT_FAILURE);
} else {
printf("内存分配成功！\n");
// 对分配的内存进行操作...
for (int i = 0; i < size; ++i) {
ptr[i] = i * 10;
printf("ptr[%d] = %d\n", i, ptr[i]);
}
// 释放分配的内存
free(ptr);
}
return 0;
}
在示例中，malloc() 被用来分配一个包含5个整数的内存块。然后，分配的内存被使用，最后通过 free() 函数释放了已分配的内存。此外，在使用 malloc() 分配内存后，通常需要检查返回的指针是否为 NULL，以确保分配操作成功。
Linux POSIX calloc() 详解
在 Linux POSIX 中的 <stdlib.h> 头文件中，calloc() 函数是用于动态内存分配的重要函数之一，类似于 malloc()。不同之处在于，calloc() 不仅分配内存，还将分配的内存块初始化为零。
函数签名：
1
void *calloc(size_t num_elements, size_t element_size);
参数：
size_t num_elements: 要分配的元素数量。size_t element_size: 每个元素的大小（以字节为单位）。
返回值：
calloc()返回一个指向分配内存的指针。如果分配失败，则返回NULL。
功能：
calloc()用于动态分配一块指定数量和大小的连续内存块，并将所有的位初始化为零。
使用示例：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
#include <stdio.h>
#include <stdlib.h>
int main() {
int *ptr;
int size = 5;
// 分配一个包含5个整数的内存块，并将其初始化为零
ptr = (int *)calloc(size, sizeof(int));
if (ptr == NULL) {
printf("内存分配失败！\n");
exit(EXIT_FAILURE);
} else {
printf("内存分配成功！\n");
// 对分配的内存进行操作...
for (int i = 0; i < size; ++i) {
printf("ptr[%d] = %d\n", i, ptr[i]);
}
// 释放分配的内存
free(ptr);
}
return 0;
}
在示例中，calloc() 被用来分配一个包含5个整数的内存块，并将其初始化为零。然后，分配的内存被使用，并通过 free() 函数释放了已分配的内存。同样，需要检查返回的指针是否为 NULL，以确保分配操作成功。
Linux POSIX realloc() 详解
在 Linux POSIX 中的 <stdlib.h> 头文件中，realloc() 函数是用于重新分配动态内存的重要函数。它允许程序修改先前分配的内存块的大小，可能扩大或缩小该内存块的大小。
函数签名：
1
void *realloc(void *ptr, size_t size);
参数：
void *ptr: 指向先前分配内存的指针。size_t size: 新的内存块大小（以字节为单位）。
返回值：
realloc()返回一个指向重新分配内存的指针。如果分配失败，则返回NULL。如果ptr为NULL，则realloc()的行为类似于malloc()。
功能：
realloc()用于更改先前分配的内存块的大小。如果内存大小增加，可能会移动现有的数据到新的内存位置，并将新分配的空间初始化为未定义的值。
使用示例：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
#include <stdio.h>
#include <stdlib.h>
int main() {
int *ptr;
int size = 5;
// 分配一个包含5个整数的内存块
ptr = (int *)malloc(size * sizeof(int));
if (ptr == NULL) {
printf("内存分配失败！\n");
exit(EXIT_FAILURE);
} else {
printf("内存分配成功！\n");
// 对分配的内存进行操作...
for (int i = 0; i < size; ++i) {
ptr[i] = i * 10;
printf("ptr[%d] = %d\n", i, ptr[i]);
}
// 重新分配内存块大小为10个整数大小
int new_size = 10;
ptr = (int *)realloc(ptr, new_size * sizeof(int));
if (ptr == NULL) {
printf("重新分配内存失败！\n");
exit(EXIT_FAILURE);
} else {
printf("重新分配内存成功！\n");
// 继续操作重新分配的内存...
for (int i = size; i < new_size; ++i) {
ptr[i] = i * 10;
printf("ptr[%d] = %d\n", i, ptr[i]);
}
}
// 释放重新分配的内存
free(ptr);
}
return 0;
}
在示例中，首先使用 malloc() 分配了一个包含5个整数的内存块。然后，使用 realloc() 函数重新分配内存块的大小为10个整数大小。需要注意的是，realloc() 可能会在必要时重新分配内存并将原始数据复制到新分配的位置。最后，通过 free() 函数释放了重新分配的内存。
Linux POSIX free() 详解
在 Linux POSIX 中的 <stdlib.h> 头文件中，free() 函数是用于释放动态分配的内存块的关键函数。
函数签名：
1
void free(void *ptr);
参数：
void *ptr: 指向先前分配内存的指针。
返回值：
free()函数没有返回值。
功能：
free()用于释放先前使用malloc()、calloc()或realloc()分配的动态内存。通过释放已分配的内存，将其返回给系统，使其可以在以后的操作中重新使用。
使用示例：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
#include <stdio.h>
#include <stdlib.h>
int main() {
int *ptr;
int size = 5;
// 分配一个包含5个整数的内存块
ptr = (int *)malloc(size * sizeof(int));
if (ptr == NULL) {
printf("内存分配失败！\n");
exit(EXIT_FAILURE);
} else {
printf("内存分配成功！\n");
// 对分配的内存进行操作...
for (int i = 0; i < size; ++i) {
ptr[i] = i * 10;
printf("ptr[%d] = %d\n", i, ptr[i]);
}
// 释放分配的内存
free(ptr);
printf("内存已释放。\n");
}
return 0;
}
在示例中，首先使用 malloc() 分配了一个包含5个整数的内存块，然后使用 free() 函数释放了该内存块。释放内存后，应避免继续使用指向已释放内存的指针，因为这可能导致未定义的行为。因此，在释放内存后，通常将指针设置为 NULL，以避免意外使用。
Linux POSIX atoi() 详解
在 Linux POSIX 中的 <stdlib.h> 头文件中，atoi() 函数用于将字符串转换为整数。
函数签名：
1
int atoi(const char *str);
参数：
const char *str: 要转换为整数的字符串。
返回值：
atoi()返回转换后的整数值。如果输入字符串不是有效的整数表示形式，则返回 0。
功能：
atoi()函数将传入的字符串参数解析为整数。它会跳过字符串开始的空格字符，然后从第一个非空格字符开始，尝试解析尽可能多的连续字符作为整数。它会忽略非数字字符，直到遇到非数字字符或字符串结束。
使用示例：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
#include <stdio.h>
#include <stdlib.h>
int main() {
const char *str = "12345";
int result = atoi(str);
printf("字符串转换为整数结果：%d\n", result);
const char *str2 = "42abc";
int result2 = atoi(str2);
printf("非完整字符串转换为整数结果：%d\n", result2);
const char *str3 = "abc";
int result3 = atoi(str3);
printf("非数字字符串转换为整数结果：%d\n", result3);
return 0;
}
在示例中，atoi() 函数被用于将不同的字符串转换为整数。第一个示例中的字符串 “12345” 被成功转换为整数 12345。第二个示例中的字符串 “42abc” 以数字部分 “42” 被成功转换为整数 42。第三个示例中的字符串 “abc” 不是有效的整数表示形式，因此 atoi() 返回 0。需要注意的是，atoi() 对于不完整或无效的输入可能会返回 0，因此在使用时需要谨慎检查返回值。
Linux POSIX atof() 详解
在 Linux POSIX 中的 <stdlib.h> 头文件中，atof() 函数用于将字符串转换为浮点数。
函数签名：
1
double atof(const char *str);
参数：
const char *str: 要转换为浮点数的字符串。
返回值：
atof()返回转换后的浮点数值。如果输入字符串不是有效的浮点数表示形式，则返回 0.0。
功能：
atof()函数将传入的字符串参数解析为浮点数。它会跳过字符串开始的空格字符，然后从第一个非空格字符开始，尝试解析尽可能多的连续字符作为浮点数。它会忽略非数字字符，直到遇到非数字字符、小数点、指数标志（如 ‘e’ 或 ‘E’）或字符串结束。
使用示例：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
#include <stdio.h>
#include <stdlib.h>
int main() {
const char *str = "123.456";
double result = atof(str);
printf("字符串转换为浮点数结果：%f\n", result);
const char *str2 = "3.14abc";
double result2 = atof(str2);
printf("非完整字符串转换为浮点数结果：%f\n", result2);
const char *str3 = "abc";
double result3 = atof(str3);
printf("非数字字符串转换为浮点数结果：%f\n", result3);
return 0;
}
在示例中，atof() 函数被用于将不同的字符串转换为浮点数。第一个示例中的字符串 “123.456” 被成功转换为浮点数 123.456。第二个示例中的字符串 “3.14abc” 以浮点数部分 “3.14” 被成功转换为浮点数 3.14。第三个示例中的字符串 “abc” 不是有效的浮点数表示形式，因此 atof() 返回 0.0。需要注意的是，atof() 对于不完整或无效的输入可能会返回 0.0，因此在使用时需要谨慎检查返回值。
Linux POSIX itoa() 详解
在 POSIX 标准中，itoa() 函数实际上不是标准 C 函数，它不在 C 标准库 <stdlib.h> 中定义。itoa() 用于将整数转换为字符串。尽管在某些特定的编译器或系统中可能会提供 itoa() 函数，但它并不是 C 语言标准库的一部分，因此在不同的系统或编译器中，itoa() 的可用性和实现方式可能会有所不同。
通常情况下，如果没有 itoa() 函数，可以使用标准库函数 sprintf() 或 snprintf() 来实现整数到字符串的转换。这两个函数允许将格式化的数据写入字符串缓冲区中。
下面是使用 snprintf() 函数将整数转换为字符串的示例：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
#include <stdio.h>
#define MAX_LENGTH 20
int main() {
int num = 12345;
char str[MAX_LENGTH];
snprintf(str, MAX_LENGTH, "%d", num);
printf("整数转换为字符串结果：%s\n", str);
return 0;
}
在此示例中，snprintf() 函数将整数 num 转换为字符串，并将结果存储在 str 缓冲区中。使用 "%d" 格式化字符串指定要转换的整数类型。这种方法提供了一种可移植且不依赖于特定编译器或系统的整数到字符串转换方式。
Linux POSIX rand() 详解
在 POSIX 中的 <stdlib.h> 头文件中，rand() 函数用于生成伪随机整数。
函数签名：
1
int rand(void);
参数：
void：rand()函数没有参数。
返回值：
rand()返回一个伪随机整数值。范围通常是 0 到RAND_MAX之间（包括 0 和RAND_MAX）。
功能：
rand()函数生成伪随机整数。每次调用rand()，它会返回一个在指定范围内的整数值。伪随机性意味着生成的数字序列是基于初始种子值的，因此在相同的种子值下，rand()将生成相同的数字序列。
使用示例：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
int main() {
int i, randomNum;
// 使用当前时间作为种子
srand(time(0));
printf("生成的随机数为：\n");
// 生成并打印 10 个随机数
for (i = 0; i < 10; ++i) {
randomNum = rand();
printf("%d\n", randomNum);
}
return 0;
}
在示例中，srand() 函数使用当前时间作为种子，以确保每次程序运行时生成的随机数序列是不同的。然后，使用 rand() 函数生成并打印了 10 个随机数。需要注意的是，如果不调用 srand() 来设置种子，每次程序运行时将会生成相同的随机数序列。因此，在许多情况下，通常在程序开始时使用不同的种子来初始化随机数生成器，以产生不同的随机数序列。
Linux POSIX srand() 详解
在 POSIX 标准的 <stdlib.h> 头文件中，srand() 函数用于设置 rand() 函数生成随机数所使用的种子值。
函数签名：
1
void srand(unsigned int seed);
参数：
unsigned int seed：用作随机数生成器种子的整数值。
返回值：
srand()函数没有返回值。
功能：
srand()函数设置rand()函数使用的种子值。这个种子值将影响rand()函数生成的随机数序列。如果使用相同的种子值调用srand()，则后续对rand()的调用将生成相同的随机数序列。
使用示例：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
int main() {
int i, randomNum;
unsigned int seed = 123; // 设置种子值
// 使用指定种子值
srand(seed);
printf("使用种子值 %u 生成的随机数为：\n", seed);
// 生成并打印 10 个随机数
for (i = 0; i < 10; ++i) {
randomNum = rand();
printf("%d\n", randomNum);
}
return 0;
}
在示例中，srand() 函数被用于设置随机数生成器的种子值为 123。然后，rand() 函数被调用多次以生成随机数序列。重要的是要注意，如果使用相同的种子值多次调用 srand()，后续对 rand() 的调用将生成相同的随机数序列。通常情况下，使用随机的种子值（比如当前时间）可以帮助确保每次程序运行时都生成不同的随机数序列。
Linux POSIX getenv() 详解
在 POSIX 标准的 <stdlib.h> 头文件中，getenv() 函数用于获取指定环境变量的值。
函数签名：
1
char *getenv(const char *name);
参数：
const char *name：要获取其值的环境变量的名称字符串。
返回值：
getenv()函数返回一个指向环境变量值的字符串指针。如果未找到指定名称的环境变量，则返回NULL。
功能：
getenv()函数用于获取指定环境变量的值。环境变量是一种在程序执行时存储有关环境信息的方式，比如系统路径、用户信息等。
使用示例：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
#include <stdio.h>
#include <stdlib.h>
int main() {
char *path = getenv("PATH");
if (path != NULL) {
printf("PATH 环境变量的值是：%s\n", path);
} else {
printf("未找到 PATH 环境变量\n");
}
return 0;
}
在示例中，getenv() 函数被用于获取名为 “PATH” 的环境变量的值。如果找到了名为 “PATH” 的环境变量，则打印其值。如果未找到指定的环境变量，则打印一条消息说明未找到该环境变量。需要注意的是，如果环境变量不存在或未定义，则 getenv() 返回 NULL。
Linux POSIX system() 详解
在 POSIX 中的 <stdlib.h> 头文件中，system() 函数用于执行命令行中的命令。
函数签名：
1
int system(const char *command);
参数：
const char *command：要执行的命令的字符串。
返回值：
system()函数返回命令执行的状态信息。返回值通常是命令退出状态的表示方式，通常情况下，0 表示命令成功执行，非零值表示出现了错误。
功能：
system()函数用于在程序中执行命令。它将传入的命令字符串发送给系统命令解释器来执行。在执行完成后，会返回命令的退出状态信息。
使用示例：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
#include <stdio.h>
#include <stdlib.h>
int main() {
// 执行命令 ls，并检查返回状态
int status = system("ls -l");
if (status == 0) {
printf("命令执行成功！\n");
} else {
printf("命令执行失败或出现错误！\n");
}
return 0;
}
在示例中，system() 函数被用于执行 ls -l 命令，并通过检查返回的状态信息来判断命令是否执行成功。需要注意的是，system() 函数执行命令后，会等待命令执行完成，并返回其退出状态信息。因此，如果执行的命令会花费很长时间，程序也会相应地等待。此外，system() 函数也可以用来执行其他的系统命令，但需要注意潜在的安全风险，尤其是当传入的命令字符串由用户输入或动态生成时。
Linux POSIX exit() 详解
在 POSIX 标准的 <stdlib.h> 头文件中，exit() 函数用于终止程序的执行，并返回一个指定的退出状态给操作系统。
函数签名：
1
void exit(int status);
参数：
int status：程序的退出状态码。通常情况下，0 表示成功退出，非零值表示出现了错误。
返回值：
exit()函数没有返回值。
功能：
exit()函数用于正常终止程序的执行。当调用exit()时，它会立即终止当前正在运行的程序，清理所有的资源并返回指定的退出状态码给操作系统。
使用示例：
1
2
3
4
5
6
7
8
9
10
11
#include <stdio.h>
#include <stdlib.h>
int main() {
printf("程序执行中...\n");
// 执行一些操作...
// 终止程序的执行，并返回退出状态码 0（表示成功）
exit(0);
}
在示例中，exit() 函数被用于正常终止程序的执行。当程序到达 exit(0) 时，程序将立即终止，并将退出状态码 0 返回给操作系统。exit() 函数可以用于在程序的任何地方终止执行，不仅仅是在 main() 函数内。
Linux POSIX abort() 详解
在 POSIX 中的 <stdlib.h> 头文件中，abort() 函数用于使程序异常终止。
函数签名：
1
void abort(void);
参数：
void：abort()函数没有参数。
返回值：
abort()函数不会返回，它会导致程序异常终止。
功能：
abort()函数用于引发程序的异常终止。调用abort()会立即终止程序的执行，并向操作系统发送一个异常终止信号。通常情况下，会生成一个SIGABRT信号，表示程序发生了严重错误，并且无法继续运行。
使用示例：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
#include <stdio.h>
#include <stdlib.h>
int main() {
printf("程序执行中...\n");
// 在某些条件下触发异常终止
int condition = 1;
if (condition) {
printf("发生错误，程序即将异常终止！\n");
abort();
}
// 这里的代码不会被执行，因为在上面已经调用了 abort()
printf("这行代码不会被执行\n");
return 0;
}
在示例中，abort() 函数被用于条件满足时触发异常终止。如果条件满足（condition 为真），则会触发 abort() 调用，导致程序立即终止，并不会执行 abort() 之后的代码。abort() 函数通常用于标记程序发生了严重错误或遇到不可恢复的情况，需要立即停止程序的执行。
Linux POSIX qsort() 详解
在 POSIX 标准的 <stdlib.h> 头文件中，qsort() 函数用于对数组进行快速排序。
函数签名：
1
void qsort(void *base, size_t nmemb, size_t size, int (*compar)(const void *, const void *));
参数：
void *base：指向要排序的数组的指针。size_t nmemb：数组中元素的数量。size_t size：每个元素的大小（以字节为单位）。int (*compar)(const void *, const void *)：指向比较函数的指针，用于定义元素之间的比较规则。
返回值：
qsort()函数没有返回值。
功能：
qsort()函数用于对数组进行快速排序。它根据提供的比较函数，按照升序排列数组元素。快速排序是一种高效的排序算法，具有较好的平均性能。
比较函数 compar：
- 比较函数
compar接受两个指向要比较的元素的指针，返回一个整数值表示它们的关系：- 如果第一个元素应排在第二个元素之前，则返回负值；
- 如果第一个元素应排在第二个元素之后，则返回正值；
- 如果两个元素相等，则返回零。
使用示例：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
#include <stdio.h>
#include <stdlib.h>
// 比较函数，用于指定排序规则（升序）
int compare(const void *a, const void *b) {
return (*(int *)a - *(int *)b);
}
int main() {
int arr[] = {5, 2, 9, 1, 5, 6};
int size = sizeof(arr) / sizeof(arr[0]);
printf("排序前的数组：\n");
for (int i = 0; i < size; ++i) {
printf("%d ", arr[i]);
}
printf("\n");
// 对数组进行快速排序
qsort(arr, size, sizeof(int), compare);
printf("排序后的数组：\n");
for (int i = 0; i < size; ++i) {
printf("%d ", arr[i]);
}
printf("\n");
return 0;
}
在示例中，qsort() 函数被用于对整数数组 arr 进行升序排序。通过提供的比较函数 compare，指定了元素之间的比较规则。qsort() 函数将数组按升序排列后，打印排序前后的数组内容。
Linux POSIX bsearch() 详解
在 POSIX 标准的 <stdlib.h> 头文件中，bsearch() 函数用于在已排序数组中执行二分查找。
函数签名：
1
void *bsearch(const void *key, const void *base, size_t nmemb, size_t size, int (*compar)(const void *, const void *));
参数：
const void *key：要查找的元素的指针。const void *base：指向已排序数组的起始地址的指针。size_t nmemb：数组中元素的数量。size_t size：每个元素的大小（以字节为单位）。int (*compar)(const void *, const void *)：指向比较函数的指针，用于定义元素之间的比较规则。
返回值：
bsearch()函数返回一个指针，指向查找到的元素的位置。如果未找到匹配的元素，则返回NULL。
功能：
bsearch()函数用于在已排序的数组中执行二分查找。它搜索数组中是否存在与指定关键字匹配的元素。二分查找是一种高效的查找算法，但要求数组必须是已排序的。
比较函数 compar：
- 比较函数
compar与qsort()函数中的比较函数类似，接受两个指向要比较的元素的指针，返回一个整数值表示它们的关系。
使用示例：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
#include <stdio.h>
#include <stdlib.h>
// 比较函数，用于指定比较规则
int compare(const void *a, const void *b) {
return (*(int *)a - *(int *)b);
}
int main() {
int arr[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
int size = sizeof(arr) / sizeof(arr[0]);
int key = 5;
// 对数组进行快速排序（必须是已排序的数组）
qsort(arr, size, sizeof(int), compare);
// 在已排序数组中执行二分查找
int *result = (int *)bsearch(&key, arr, size, sizeof(int), compare);
if (result != NULL) {
printf("元素 %d 找到在数组中的位置：%ld\n", key, result - arr);
} else {
printf("元素 %d 未找到在数组中\n", key);
}
return 0;
}
在示例中，bsearch() 函数被用于在已排序数组 arr 中查找元素 key。首先，数组必须是已排序的，然后使用 qsort() 对其进行排序。然后调用 bsearch() 函数来寻找 key，并根据返回结果确定是否找到该元素。如果找到，bsearch() 返回指向匹配元素的指针，否则返回 NULL。
C putenv() 函数 详解
putenv() 函数用于设置环境变量。它是C标准库中的一部分，定义在 <stdlib.h> 头文件中。
函数原型
1
int putenv(char *string);
参数
string：一个以形式name=value表示的字符串，用于设置环境变量。这个字符串会被函数复制，因此你可以在调用后安全地释放它。
返回值
- 如果设置环境变量成功，则返回0；否则返回一个非零值。
注意事项
putenv()在某些平台上可能不是线程安全的，因此在多线程环境中使用时需要小心。- 在某些平台上，使用
putenv()可能会导致内存泄漏，因为它只是修改了指向环境变量的指针，而不是为其分配新的内存空间。 - 在某些操作系统上，对环境变量的更改可能会影响整个程序的行为，因此使用
putenv()需要谨慎。
示例
下面是一个简单的示例，演示了如何使用 putenv() 设置一个环境变量：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
#include <stdlib.h>
#include <stdio.h>
int main() {
// 设置环境变量
char env_var[] = "MY_ENV_VAR=Hello World";
if (putenv(env_var) != 0) {
fprintf(stderr, "Failed to set environment variable\n");
return 1;
}
// 获取环境变量并输出
char* value = getenv("MY_ENV_VAR");
if (value != NULL) {
printf("Value of MY_ENV_VAR: %s\n", value);
} else {
fprintf(stderr, "MY_ENV_VAR is not set\n");
}
return 0;
}
在这个示例中，我们设置了一个名为 MY_ENV_VAR 的环境变量，其值为 Hello World。然后，我们获取并输出这个环境变量的值。