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 流(例如 stdoutstderr)。

参数:

  • 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_attribtype 分别指定内存区域的缓存属性和类型。返回一个整数值,表示是否成功创建内存区域。如果成功,则返回 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 指定内存池的起始地址,而 sizecache_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 1024

int 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 1024

int 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() 函数删除了管道对象。