用c++语言写程序，具体要求：一些进程将自己的输出数据写到磁盘文件里，并将输出文件名写到进程间共享的内存里。打印守护进程从共享内存里读取文件名，将磁盘文件的数据输出到屏幕上。 在共享内存里实现环形队列，对共享内存的访问要保证互斥。输出进程和 打印守护进程要实现同步。

好的，您的问题是如何实现这个要求，是吗？那么我可以给您提供一些思路和代码示例，帮助您完成这个任务。

首先，我们需要定义一个环形队列的结构体，来存储共享内存中的数据：

struct Queue {
    int head;
    int tail;
    int size;
    char buffer[MAX_BUFFER_SIZE][MAX_FILE_NAME_LENGTH];
};

其中，`head`表示队列头指针，`tail`表示队列尾指针，`size`表示队列的容量，`buffer`表示实际存储数据的数组。`MAX_BUFFER_SIZE`和`MAX_FILE_NAME_LENGTH`是常量，分别表示队列的最大容量和文件名的最大长度。

接下来，我们可以定义一个进程，用来写入数据到共享内存里：

void write_process() {
    // 打开共享内存
    int shmid = shmget(KEY, sizeof(Queue), IPC_CREAT | 0666);
    Queue* queue = (Queue*)shmat(shmid, NULL, 0);

    // 打开文件
    FILE* fp = fopen("output.txt", "w");

    // 不断写入数据
    while (true) {
        // 等待互斥锁
        sem_wait(mutex);

        // 判断队列是否已满
        if ((queue->tail + 1) % queue->size == queue->head) {
            // 队列已满，等待条件变量
            sem_post(mutex);
            sem_wait(full);
        }

        // 将文件名写入队列
        strcpy(queue->buffer[queue->tail], "output.txt");
        queue->tail = (queue->tail + 1) % queue->size;

        // 释放互斥锁
        sem_post(mutex);

        // 将数据写入文件
        fprintf(fp, "Hello, world!\n");

        // 通知打印进程
        sem_post(empty);
    }

    // 关闭文件
    fclose(fp);

    // 分离共享内存
    shmdt(queue);
}

这个进程会不断写入数据到文件中，并将文件名写入共享内存的环形队列里。在写入数据之前，需要等待互斥锁，保证多个进程不会同时访问共享内存。如果队列已满，则等待条件变量`full`。写入完成后，释放互斥锁，并通知打印进程，可以开始读取数据了。

接下来，我们可以定义一个守护进程，用来读取共享内存里的数据，并将其输出到屏幕上：

void print_daemon() {
    // 打开共享内存
    int shmid = shmget(KEY, sizeof(Queue), IPC_CREAT | 0666);
    Queue* queue = (Queue*)shmat(shmid, NULL, 0);

    // 不断读取数据
    while (true) {
        // 等待互斥锁
        sem_wait(mutex);

        // 判断队列是否为空
        if (queue->head == queue->tail) {
            // 队列为空，等待条件变量
            sem_post(mutex);
            sem_wait(empty);
        }

        // 从队列中取出文件名
        char file_name[MAX_FILE_NAME_LENGTH];
        strcpy(file_name, queue->buffer[queue->head]);
        queue->head = (queue->head + 1) % queue->size;

        // 释放互斥锁
        sem_post(mutex);

        // 打开文件并输出数据
        FILE* fp = fopen(file_name, "r");
        char buffer[MAX_BUFFER_SIZE];
        while (fgets(buffer, MAX_BUFFER_SIZE, fp)) {
            printf("%s", buffer);
        }
        fclose(fp);

        // 通知写入进程
        sem_post(full);
    }

    // 分离共享内存
    shmdt(queue);
}

这个守护进程会不断读取共享内存里的数据，如果队列为空，则等待条件变量`empty`。读取完成后，释放互斥锁，并将数据输出到屏幕上。输出完成后，通知写入进程，可以继续写入数据了。

最后，我们需要在主函数里创建互斥锁和条件变量，并启动写入进程和守护进程：

int main() {
    // 创建互斥锁和条件变量
    mutex = sem_open(MUTEX_NAME, O_CREAT, 0644, 1);
    full = sem_open(FULL_NAME, O_CREAT, 0644, 0);
    empty = sem_open(EMPTY_NAME, O_CREAT, 0644, 0);

    // 创建写入进程和守护进程
    pid_t pid = fork();
    if (pid == 0) {
        write_process();
    } else {
        print_daemon();
    }

    // 等待子进程退出
    wait(NULL);

    // 关闭互斥锁和条件变量
    sem_close(mutex);
    sem_close(full);
    sem_close(empty);

    // 删除共享内存
    shmctl(shmid, IPC_RMID, NULL);

    return 0;
}

这样，我们就完成了一个简单的操作系统课程设计假脱机程序，实现了多个进程之间的同步和互斥。