帮我用c语言写一个函数，这个函数放在公用库里面，有设置和取值功能，值是不知道多大的，一个进程while一直运行取值，而后另一个进程进行设置，

当需要在两个进程之间进行进程间通信时，可以使用共享内存和信号量来实现。下面是一个示例函数，其中包含了设置和获取共享内存的功能：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/ipc.h>
#include <sys/shm.h>
#include <sys/types.h>
#include <sys/sem.h>

#define SHM_SIZE 1024 // 共享内存的大小

typedef struct {
    int sem_id; // 信号量ID
    int shm_id; // 共享内存ID
    char *shm_addr; // 共享内存地址
} SharedData;

SharedData *initSharedData(key_t key) {
    SharedData *shared_data = malloc(sizeof(SharedData));
    if (shared_data == NULL) {
        perror("Failed to allocate memory for SharedData");
        return NULL;
    }

    // 创建共享内存
    shared_data->shm_id = shmget(key, SHM_SIZE, IPC_CREAT | 0666);
    if (shared_data->shm_id == -1) {
        perror("Failed to create shared memory");
        free(shared_data);
        return NULL;
    }

    // 附加共享内存
    shared_data->shm_addr = shmat(shared_data->shm_id, NULL, 0);
    if (shared_data->shm_addr == (char *) -1) {
        perror("Failed to attach shared memory");
        free(shared_data);
        return NULL;
    }

    // 创建信号量
    shared_data->sem_id = semget(key, 1, IPC_CREAT | 0666);
    if (shared_data->sem_id == -1) {
        perror("Failed to create semaphore");
        free(shared_data);
        return NULL;
    }

    // 初始化信号量
    union semun {
        int val;
        struct semid_ds *buf;
        ushort *array;
    } sem_arg;
    sem_arg.val = 1; // 初始值为1
    if (semctl(shared_data->sem_id, 0, SETVAL, sem_arg) == -1) {
        perror("Failed to initialize semaphore");
        free(shared_data);
        return NULL;
    }

    return shared_data;
}

void setSharedValue(SharedData *shared_data, const char *value) {
    // 获取信号量
    struct sembuf sem_op;
    sem_op.sem_num = 0;
    sem_op.sem_op = -1; // 等待信号量的值为0
    sem_op.sem_flg = 0;
    if (semop(shared_data->sem_id, &sem_op, 1) == -1) {
        perror("Failed to acquire semaphore");
        return;
    }

    // 设置共享内存的值
    strncpy(shared_data->shm_addr, value, SHM_SIZE);

    // 释放信号量
    sem_op.sem_op = 1; // 信号量的值加1
    if (semop(shared_data->sem_id, &sem_op, 1) == -1) {
        perror("Failed to release semaphore");
        return;
    }
}

void getSharedValue(SharedData *shared_data, char *value, size_t size) {
    // 获取信号量
    struct sembuf sem_op;
    sem_op.sem_num = 0;
    sem_op.sem_op = -1; // 等待信号量的值为0
    sem_op.sem_flg = 0;
    if (semop(shared_data->sem_id, &sem_op, 1) == -1) {
        perror("Failed to acquire semaphore");
        return;
    }

    // 获取共享内存的值
    strncpy(value, shared_data->shm_addr, size - 1);
    value[size - 1] = '\0';

    // 释放信号量
    sem_op.sem_op = 1; // 信号量的值加1
    if (semop(shared_data->sem_id, &sem_op, 1) == -1) {
        perror("Failed to release semaphore");
        return;
    }
}

void destroySharedData(SharedData *shared_data) {
    // 分离共享内存
    if (shmdt(shared_data->shm_addr) == -1) {
        perror("Failed to detach shared memory");
    }

    // 删除共享内存
    if (shmctl(shared_data->shm_id, IPC_RMID, NULL) == -1) {
        perror("Failed to delete shared memory");
    }

    // 删除信号量
    if (semctl(shared_data->sem_id, 0, IPC_RMID) == -1) {
        perror("Failed to delete semaphore");
    }

    free(shared_data);
}

使用示例：

#include <stdio.h>
#include "shared_data.h"

int main() {
    key_t key = ftok("shared_data_example", 'A');
    if (key == -1) {
        perror("Failed to generate key");
        return 1;
    }

    SharedData *shared_data = initSharedData(key);
    if (shared_data == NULL) {
        return 1;
    }

    // 设置共享值
    setSharedValue(shared_data, "Hello, World!");

    // 获取共享值
    char value[SHM_SIZE];
    getSharedValue(shared_data, value, sizeof(value));
    printf("Value: %s\n", value);

    destroySharedData(shared_data);

    return 0;
}

在示例中，我们使用了`initSharedData`函数来初始化共享内存和信号量。`setSharedValue`函数用于设置共享值，而`getSharedValue`函数用于获取共享值。最后，我们使用`destroySharedData`函数来销毁共享内存和信号量。

请注意，在使用共享内存和信号量时，需要确保两个进程使用相同的关键字（key）来访问共享内存和信号量。

希望这个函数能满足你的需求！如果你还有其他问题，请随时提问。