C语言函数大全
本篇介绍C语言函数大全-- q 开头的函数
1. qsort
1.1 函数说明
| 函数声明 | 函数功能 |
|---|---|
void qsort(void *base, size_t nmemb, size_t size, int (*compar)(const void *, const void *)); | 用于将指定数组按指定顺序进行排序 |
参数：
- base ： 指向要排序的数组的第一个元素的指针
- nmemb ： 表示数组中元素的数量
- size ： 表示每个元素的大小（以字节为单位）
- compar ： 指向一个函数，用于比较两个元素的值。该函数需要接受两个 const void* 类型的参数，分别指向要比较的两个元素，并返回一个整数值，表示它们的相对顺序。
1.2 演示示例
#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, 8, 4, 1, 9, 3, 6, 7 };size_t n = sizeof(arr) / sizeof(int);printf("Before sorting:");for (int i = 0; i < n; i++) {printf(" %d", arr[i]);}printf("\n");qsort(arr, n, sizeof(int), compare);printf("After sorting:");for (int i = 0; i < n; i++) {printf(" %d", arr[i]);}printf("\n");return 0;
}
在上述的示例中，
- 我们首先定义了一个整数数组
arr，并计算出数组的长度，赋值给n； - 接着我们输出原始数组
"Before sorting: 5 2 8 4 1 9 3 6 7" - 然后我们使用
qsort()函数将其按照升序排列。qsort()函数中传入一个比较函数compare()，用于比较两个元素的值。 - 最后我们再次输出排序后的结果
”After sorting: 1 2 3 4 5 6 7 8 9“。
注意： 在编写比较函数时，需要根据元素的实际类型进行转换，并确保返回值符合要求（小于零表示第一个元素小于第二个元素，等于零表示两个元素相等，大于零表示第一个元素大于第二个元素）。此外，还需要特别注意参数类型和返回值类型的
const限定符。
1.3 运行结果
2. quick_exit
2.1 函数说明
| 函数声明 | 函数功能 |
|---|---|
void quick_exit(int status); | 它是 C11 标准中新增的函数，用于快速退出程序并执行一些清理操作。它类似于 exit() 函数，但不会调用 atexit() 注册的函数，并且不会刷新标准 I/O 流（例如 stdout 和 stderr）。 |
参数：
- status ：程序退出时返回的状态码，0 表示程序正常退出，非零值表示出现了异常情况。
2.2 演示示例
#include <stdio.h>
#include <stdlib.h>void cleanup() {printf("Cleaning up...\n");
}int main() {if (at_quick_exit(cleanup) != 0) {fprintf(stderr, "Failed to register cleanup function\n");exit(EXIT_FAILURE);}printf("Running...\n");quick_exit(EXIT_SUCCESS);
}
在如上的示例中，
- 我们首先使用
at_quick_exit()函数注册一个清理函数cleanup()，当程序使用quick_exit()函数退出时，该函数会自动执行。 - 然后，我们调用
quick_exit()函数并传入状态码EXIT_SUCCESS表示程序正常退出。
注意： 在使用
quick_exit()函数时需要特别小心，因为它不会调用atexit()注册的函数，并且可能导致一些资源泄漏或未完成的操作。只有在必须立即结束程序并执行清理操作时，才应该使用该函数。
3. qunsetenv
3.1 函数说明
| 函数声明 | 函数功能 |
|---|---|
int qunsetenv(const char *name); | 用于从进程环境中移除指定的环境变量。该函数在某些操作系统上可能不可用，因为它并非标准的 C 语言函数，而是 POSIX 标准中定义的函数。 |
参数：
- name ： 要移除的环境变量的名称
返回值：
- 如果环境变量不存在，则不进行任何操作，并返回
0；- 否则将其移除，并返回一个非零值。
3.2 演示示例
#include <stdlib.h>
#include <stdio.h>int main() {// 设置一个环境变量setenv("MY_VAR", "hello world", 1);// 移除这个环境变量if (qunsetenv("MY_VAR") != 0) {perror("qunsetenv() failed");exit(EXIT_FAILURE);}// 尝试访问这个环境变量char *val = getenv("MY_VAR");if (val == NULL) {printf("Environment variable MY_VAR has been removed.\n");} else {printf("Unexpected value: %s\n", val);}return EXIT_SUCCESS;
}
在上述这个示例程序中，
- 我们首先使用
setenv()函数设置了一个名为MY_VAR的环境变量； - 然后使用
qunsetenv()函数移除了这个环境变量； - 最后再次尝试访问这个环境变量，如果返回值为
NULL，则说明环境变量已经被成功移除了。
注意： 使用
qunsetenv()函数可以修改当前进程的环境变量，但是对于其他进程或子进程来说，它们的环境变量不受影响。此外，一些操作系统可能不支持对环境变量进行动态修改，因此无法保证qunsetenv()函数在所有平台上都能正常工作。
4. QURT
4.1 函数说明
| 函数声明 | 函数功能 |
|---|---|
void *qurt_sysenv_getvirtaddr(void *phys_addr, unsigned int size); | 将物理地址转换为虚拟地址。 |
void *qurt_malloc(unsigned int size); | 动态分配内存 |
void *qurt_calloc(unsigned int nmemb, unsigned int size); | 动态分配内存，并初始化为零。 |
void qurt_free(void *ptr); | 释放动态分配的内存。 |
int qurt_thread_create(qurt_thread_t *tid, const qurt_thread_attr_t *attr, void (*start)(void *), void *arg); | 创建新线程。 |
int qurt_thread_join(qurt_thread_t tid, int *status); | 等待线程结束并释放其资源。 |
unsigned int qurt_thread_get_priority(qurt_thread_t thread); | 用于获取指定线程的优先级。其中参数 thread 是要获取优先级的线程的句柄。返回一个无符号整数，表示线程的优先级。 |
void qurt_thread_set_priority(qurt_thread_t thread, unsigned int priority); | 用于设置指定线程的优先级。其中参数 thread 是要设置优先级的线程的句柄，而参数 priority 是要设置的优先级值。 |
char *qurt_thread_get_name(char *name, qurt_thread_t thread); | 用于获取指定线程的名称。其中参数 name 是一个指向存储线程名称的缓冲区的指针，而参数 thread 是要获取名称的线程的句柄。返回一个指向缓冲区中存储线程名称的指针。 |
void qurt_thread_set_name(qurt_thread_t thread, const char *name); | 用于设置指定线程的名称。其中参数 thread 是要设置名称的线程的句柄，而参数 name 是要设置的线程名称。 |
int qurt_thread_stop(qurt_thread_t thread); | 用于停止指定线程的执行，即立即终止线程的运行。其中参数 thread 是要停止执行的线程的句柄。返回一个整数值，表示是否成功停止线程。如果成功，则返回 0；否则返回一个负数错误代码。 |
int qurt_thread_resume(qurt_thread_t thread); | 用于恢复指定线程的执行，即让线程从上次暂停处继续运行。其中参数 thread 是要恢复执行的线程的句柄。返回一个整数值，表示是否成功恢复线程。如果成功，则返回 0；否则返回一个负数错误代码。 |
void qurt_mutex_init(qurt_mutex_t *mutex); | 用于初始化一个互斥锁，即在使用之前必须进行初始化。其中参数 mutex 是指向要初始化的互斥锁对象的指针。 |
void qurt_mutex_lock(qurt_mutex_t *mutex); | 用于以阻塞方式获取一个互斥锁。如果该互斥锁已被其他线程锁定，则当前线程将一直等待，直到可以获取该锁。其中参数 mutex 是指向要获取的互斥锁对象的指针。 |
void qurt_mutex_unlock(qurt_mutex_t *mutex); | 用于释放一个互斥锁，即解除对该互斥锁的占用。其中参数 mutex 是指向要释放的互斥锁对象的指针。 |
void qurt_timer_sleep(unsigned int ticks); | 用于让当前线程进入休眠状态，休眠时间由参数 ticks 指定（每个 tick 的长度取决于系统时钟频率）。在休眠期间，该线程将不会被调度执行。注意，该函数可能会提前唤醒线程，因此休眠时间并不精确。 |
void qurt_signal_init(qurt_signal_t *signal); | 用于初始化一个信号量，即在使用之前必须进行初始化。其中参数 signal 是指向要初始化的信号量对象的指针。 |
unsigned int qurt_signal_wait(qurt_signal_t *signal, unsigned int mask, unsigned int option, unsigned int *ret_signal); | 用于等待一个或多个信号量的触发。其中参数 signal 是指向要等待的信号量对象的指针，参数 mask 表示要等待哪些信号量，参数 option 用于指定等待的行为选项，参数 ret_signal 用于返回实际触发的信号量。 |
void qurt_signal_set(qurt_signal_t *signal, unsigned int mask); | 用于触发一个或多个信号量。其中参数 signal 是指向要触发的信号量对象的指针，参数 mask 表示要触发哪些信号量。 |
void qurt_signal2_init(qurt_signal2_t *signal); | 用于初始化一个带有两个信号量的信号量对象。其中参数 signal 是指向要初始化的信号量对象的指针。 |
void qurt_signal2_destroy(qurt_signal2_t *signal); | 用于销毁带有两个信号量的信号量对象，并释放其占用的内存空间。其中参数 signal 是要销毁的信号量对象的指针。 |
void qurt_signal2_set(qurt_signal2_t *signal, unsigned int mask); | 用于设置带有两个信号量的信号量对象中的一个或多个信号量。其中参数 signal 是要设置信号量的信号量对象的指针，而参数 mask 是一个 32 位无符号整数，表示要设置的信号量掩码。掩码中每个位代表一个信号量，如果该位为 1，则表示相应的信号量被设置；如果该位为 0，则表示相应的信号量未被设置。 |
unsigned int qurt_signal2_wait(qurt_signal2_t *signal, unsigned int mask, unsigned int options); | 用于等待带有两个信号量的信号量对象中指定的信号量被触发。其中参数 signal 是要等待的信号量对象的指针，而参数 mask 是一个 32 位无符号整数，表示要等待的信号量掩码。掩码中每个位代表一个信号量，如果该位为 1，则表示相应的信号量需要被触发；如果该位为 0，则表示相应的信号量不需要被触发。参数 options 则指定等待信号量的选项，例如是否超时等。它返回一个 32 位无符号整数，表示哪些信号量已被触发。返回值中每个位代表一个信号量，如果该位为 1，则表示相应的信号量已被触发；如果该位为 0，则表示相应的信号量未被触发。 |
void qurt_timer_create(qurt_timer_t *timer, const char *name); | 用于创建一个新的定时器。其中参数 timer 是指向要创建的定时器对象的指针，参数 name 是定时器的名称（可以为 NULL）。 |
void qurt_timer_delete(qurt_timer_t timer); | 用于删除一个已经创建的定时器。其中参数 timer 是要删除的定时器对象。 |
void qurt_timer_start(qurt_timer_t timer, uint32_t duration); | 用于启动一个定时器，并指定定时器的超时时间。其中参数 timer 是要启动的定时器对象，参数 duration 是定时器的超时时间（以 tick 为单位）。 |
void qurt_timer_stop(qurt_timer_t timer); | 用于停止一个已经运行的定时器。其中参数 timer 是要停止的定时器对象。 |
qurt_thread_t qurt_thread_get_id(void); | 用于获取当前线程的 ID。 |
int qurt_mem_region_create(qurt_mem_region_t *region, unsigned int size, qurt_mem_cache_mode_t cache_attrib, qurt_mem_region_type_t type); | 用于创建一个内存区域对象，并分配指定大小的内存空间。其中参数 region 是指向要创建的内存区域对象的指针，参数 size 指定内存区域的大小，而 cache_attrib 和 type 分别指定内存区域的缓存属性和类型。返回一个整数值，表示是否成功创建内存区域。如果成功，则返回 0；否则返回一个负数错误代码。 |
int qurt_mem_region_delete(qurt_mem_region_t region); | 用于删除指定的内存区域对象，并释放其占用的内存空间。其中参数 region 是要删除的内存区域对象的句柄。返回一个整数值，表示是否成功删除内存区域。如果成功，则返回 0；否则返回一个负数错误代码。 |
void qurt_mem_region_attr_init(qurt_mem_region_attr_t *attr); | 用于初始化一个内存区域属性对象。其中参数 attr 是指向要初始化的内存区域属性对象的指针。 |
int qurt_mem_pool_create(qurt_mem_pool_t *pool, void *baseaddr, unsigned int size, qurt_mem_cache_mode_t cache_attrib); | 用于创建一个内存池对象，并分配指定大小的内存空间。其中参数 pool 是指向要创建的内存池对象的指针，参数 baseaddr 指定内存池的起始地址，而 size 和 cache_attrib 分别指定内存池的大小和缓存属性。返回一个整数值，表示是否成功创建内存池。如果成功，则返回 0；否则返回一个负数错误代码。 |
int qurt_mem_pool_delete(qurt_mem_pool_t pool); | 用于删除指定的内存池对象，并释放其占用的内存空间。其中参数 pool 是要删除的内存池对象的句柄。返回一个整数值，表示是否成功删除内存池。如果成功，则返回 0；否则返回一个负数错误代码。 |
int qurt_pipe_create(qurt_pipe_t *pipe, unsigned int pipe_type, unsigned int pipe_elements, unsigned int elem_size); | 用于创建一个管道对象，并分配指定大小的内存空间。其中参数 pipe 是指向要创建的管道对象的指针，参数 pipe_type 指定管道类型，参数 pipe_elements 指定管道元素个数，而 elem_size 指定每个管道元素的大小。 返回一个整数值，表示是否成功创建管道。如果成功，则返回 0；否则返回一个负数错误代码。 |
int qurt_pipe_delete(qurt_pipe_t pipe); | 用于删除指定的管道对象，并释放其占用的内存空间。其中参数 pipe 是要删除的管道对象的句柄。返回一个整数值，表示是否成功删除管道。如果成功，则返回 0；否则返回一个负数错误代码。 |
int qurt_pipe_send(qurt_pipe_t pipe_id, void *buf, unsigned int size, unsigned int timeout); | 用于向指定的管道发送数据。其中参数 pipe_id 是要发送数据的管道对象的句柄，参数 buf 指向要发送的数据缓冲区，参数 size 指定要发送的数据大小，而 timeout 指定等待发送操作完成的超时时间（单位为 ticks）。 返回一个整数值，表示是否成功发送数据。如果成功，则返回 0；否则返回一个负数错误代码。 |
int qurt_pipe_receive(qurt_pipe_t pipe_id, void *buf, unsigned int size, unsigned int *recv_size, unsigned int timeout); | 用于从指定的管道接收数据。其中参数 pipe_id 是要接收数据的管道对象的句柄，参数 buf 指向接收数据的缓冲区，参数 size 指定要接收的数据大小，而 recv_size 是一个指针，用于返回实际接收到的数据大小。参数 timeout 指定等待接收操作完成的超时时间（单位为 ticks）。返回一个整数值，表示是否成功接收数据。如果成功，则返回 0；否则返回一个负数错误代码。 |
4.2 演示示例
4.2.1 QuRT 创建线程示例
#include <stdio.h>
#include "qurt.h"void task1(void *arg) {printf("Task 1 is running...\n");printf("Task 1 is done.\n");
}void task2(void *arg) {printf("Task 2 is running...\n");printf("Task 2 is done.\n");
}int main() {qurt_thread_t t1, t2;qurt_thread_attr_t attr;qurt_thread_attr_init(&attr);qurt_thread_create(&t1, &attr, (void (*)(void *))task1, NULL);qurt_thread_create(&t2, &attr, (void (*)(void *))task2, NULL);qurt_thread_join(t1, NULL);qurt_thread_join(t2, NULL);return 0;
}
在上述的示例中，我们使用 qurt_thread_create() 函数创建了两个线程，分别执行 task1() 和 task2() 函数，并使用 qurt_thread_join() 函数等待它们结束。
注意： 在开发过程中，需要根据实际情况合理使用内存管理函数和多任务调度函数，并避免出现死锁、资源泄漏等问题。
4.2.2 QuRT 互斥锁示例
#include "qurt.h"
#include <stdio.h>// 共享资源
int global_counter = 0;// 互斥锁对象
static qurt_mutex_t mutex;int main() {// 初始化互斥锁对象qurt_mutex_init(&mutex);// 创建两个线程，同时访问共享资源qurt_thread_t thread1, thread2;qurt_thread_create(&thread1, NULL, increment_global_counter, NULL);qurt_thread_create(&thread2, NULL, increment_global_counter, NULL);// 等待两个线程结束qurt_thread_join(thread1, NULL);qurt_thread_join(thread2, NULL);// 输出最终结果printf("Global counter: %d\n", global_counter);return 0;
}void increment_global_counter(void *arg) {for (int i = 0; i < 1000000; ++i) {// 获取互斥锁qurt_mutex_lock(&mutex);// 访问共享资源++global_counter;// 释放互斥锁qurt_mutex_unlock(&mutex);}
}
在上面这个示例程序中，
- 我们首先使用
qurt_mutex_init()函数初始化了一个互斥锁对象。 - 然后创建了两个线程，它们都会调用
increment_global_counter()函数来增加全局计数器global_counter的值。由于多个线程可能同时访问该共享资源，因此在访问之前需要先获取互斥锁，以避免竞争条件的发生。在increment_global_counter()函数中，我们使用qurt_mutex_lock()函数获取互斥锁，并使用qurt_mutex_unlock()函数释放互斥锁。 - 最后，我们在主函数中输出了最终的计数器值。
4.2.3 QuRT 信号量示例
#include "qurt.h"
#include <stdio.h>// 共享资源
int global_counter = 0;// 信号量对象
static qurt_signal_t sem;int main() {// 初始化信号量对象qurt_signal_init(&sem);// 创建两个线程，分别增加和减少全局计数器的值qurt_thread_t thread1, thread2;qurt_thread_create(&thread1, NULL, increment_global_counter, NULL);qurt_thread_create(&thread2, NULL, decrement_global_counter, NULL);// 等待两个线程结束qurt_thread_join(thread1, NULL);qurt_thread_join(thread2, NULL);// 输出最终结果printf("Global counter: %d\n", global_counter);return 0;
}void increment_global_counter(void *arg) {for (int i = 0; i < 1000000; ++i) {// 等待信号量qurt_signal_wait(&sem, 1, QURT_SIGNAL_ATTR_WAIT_ANY, NULL);// 访问共享资源++global_counter;// 触发信号量qurt_signal_set(&sem, 1);}
}void decrement_global_counter(void *arg) {for (int i = 0; i < 1000000; ++i) {// 等待信号量qurt_signal_wait(&sem, 1, QURT_SIGNAL_ATTR_WAIT_ANY, NULL);// 访问共享资源--global_counter;// 触发信号量qurt_signal_set(&sem, 1);}
}
在上述的示例程序中，
- 我们首先使用
qurt_signal_init()函数初始化了一个信号量对象。 - 然后创建了两个线程，一个增加全局计数器的值，一个减少全局计数器的值。由于多个线程同时访问该共享资源，因此需要使用信号量进行同步。在每个线程中，我们使用
qurt_signal_wait()函数等待信号量，当信号量触发时才能访问共享资源，并使用qurt_signal_set()函数释放信号量。 - 接着 使用
qurt_thread_join()函数等待两个线程结束； - 最后输出最终结果。
4.2.4 QuRT 定时器示例
#include "qurt.h"
#include <stdio.h>// 定时器对象
static qurt_timer_t timer;// 定时器回调函数
void timer_callback(int arg) {printf("Timer expired\n");
}int main() {// 创建定时器对象qurt_timer_create(&timer, NULL);// 启动定时器qurt_timer_start(timer, 1000);// 注册定时器回调函数qurt_timer_set_attr(timer, QURT_TIMER_ATTR_CALLBACK_FUNCTION, (void *)timer_callback);qurt_timer_set_attr(timer, QURT_TIMER_ATTR_CALLBACK_ARGUMENT, (void *)0);// 等待定时器超时while (1) {qurt_timer_sleep(10);}// 停止定时器qurt_timer_stop(timer);// 删除定时器对象qurt_timer_delete(timer);return 0;
}
在上述的示例程序中，
- 我们首先使用
qurt_timer_create()函数创建了一个定时器。 - 然后使用
qurt_timer_start()函数启动了该定时器，并指定了定时器的超时时间（1000毫秒）。 - 接着使用
qurt_timer_set_attr()函数注册了定时器回调函数。 - 最后进入一个无限循环，每隔
10毫秒调用qurt_timer_sleep()函数进入休眠状态，等待定时器超时。当定时器超时时，将触发定时器回调函数 timer_callback()，输出一条消息。
注意： 在程序结束时需要使用
qurt_timer_stop()停止定时器，并使用qurt_timer_delete()删除定时器对象。
4.2.5 QuRT 共享内存区域示例
#include "qurt.h"
#include <stdio.h>#define SHM_SIZE 1024int main() {// 创建共享内存区域qurt_mem_region_t shm;qurt_mem_region_attr_t attr;qurt_mem_region_attr_init(&attr);qurt_mem_region_create(&shm, SHM_SIZE, QURT_MEM_CACHE_NONE, QURT_MEM_REGION_SHARED | QURT_MEM_REGION_PERM_READ | QURT_MEM_REGION_PERM_WRITE);// 在共享内存区域中写入数据char *buf = (char *)qurt_mem_region_get_vaddr(&shm);sprintf(buf, "Hello, shared memory!");// 打印从共享内存区域中读取的数据printf("%s\n", buf);// 删除共享内存区域qurt_mem_region_delete(shm);return 0;
}
在上述这个示例程序中，
- 我们首先使用
qurt_mem_region_create()函数创建了一个大小为SHM_SIZE的共享内存区域，并设置其缓存属性为QURT_MEM_CACHE_NONE，类型为QURT_MEM_REGION_SHARED，并且具有读写权限。 - 然后，在共享内存区域中写入了一些数据，并使用
printf()函数打印了从共享内存区域中读取的数据。 - 最后，使用
qurt_mem_region_delete()函数删除了共享内存区域。
4.2.6 QuRT 使用管道进行进程间通信的示例
#include "qurt.h"
#include <stdio.h>#define PIPE_SIZE 1024int main() {// 创建管道qurt_pipe_t pipe;qurt_pipe_create(&pipe, QURT_PIPE_ATTR_BLOCKING | QURT_PIPE_ATTR_PIPE_TYPE_BYTE_QUEUE, PIPE_SIZE, 1);// 创建子进程qurt_thread_t child;qurt_thread_create(&child, NULL, child_thread, (void *)&pipe);// 向管道发送数据char msg[] = "Hello, pipe!";qurt_pipe_send(pipe, msg, sizeof(msg), QURT_TIME_WAIT_FOREVER);// 等待子进程结束qurt_thread_join(child, NULL);// 删除管道qurt_pipe_delete(pipe);return 0;
}void child_thread(void *arg) {// 从管道接收数据char buf[PIPE_SIZE];unsigned int recv_size;qurt_pipe_receive(*(qurt_pipe_t *)arg, buf, PIPE_SIZE, &recv_size, QURT_TIME_WAIT_FOREVER);// 打印从管道中接收到的数据printf("%s\n", buf);
}
在上述示例程序中，
- 我们首先使用
qurt_pipe_create()函数创建一个大小为 1024 字节的管道对象，属性设置为阻塞式字节队列。 - 然后我们使用
qurt_thread_create()函数创建了一个名为child的子线程，并将管道对象传递给它。我们在child_thread()函数中调用了qurt_pipe_receive()函数来从管道接收数据，然后使用printf()函数打印出接收到的字符串。 - 接着我们定义了一个字符串
msg，并使用qurt_pipe_send()函数向管道发送该字符串。 - 最后我们使用
qurt_pipe_delete()函数删除了管道对象。
