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

好的，我可以为您提供一个基本的C++代码框架，用于实现您的假脱机系统。代码如下：

#include <iostream>
#include <fstream>
#include <string>
#include <unistd.h>
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/shm.h>
#include <semaphore.h>

using namespace std;

#define SHM_SIZE 4096
#define QUEUE_SIZE 10

struct Queue {
    string file_names[QUEUE_SIZE];
    int front;
    int rear;
};

int main() {
    // 创建共享内存
    int shmid = shmget(IPC_PRIVATE, SHM_SIZE, IPC_CREAT | 0666);
    if (shmid == -1) {
        cout << "Error: Failed to create shared memory." << endl;
        return 1;
    }

    // 连接共享内存
    char *shm_ptr = (char *)shmat(shmid, NULL, 0);
    if (shm_ptr == (char *)-1) {
        cout << "Error: Failed to attach shared memory." << endl;
        return 1;
    }

    // 初始化共享内存
    Queue *queue = (Queue *)shm_ptr;
    queue->front = queue->rear = 0;

    // 初始化互斥锁和信号量
    sem_t *mutex = sem_open("/mutex", O_CREAT, 0644, 1);
    sem_t *empty = sem_open("/empty", O_CREAT, 0644, QUEUE_SIZE);
    sem_t *full = sem_open("/full", O_CREAT, 0644, 0);

    // 创建子进程
    pid_t pid = fork();

    if (pid == -1) {
        cout << "Error: Failed to create child process." << endl;
        return 1;
    } else if (pid == 0) {
        // 子进程为输出进程
        ofstream fout;
        string file_name;
        while (true) {
            // 从键盘读取文件名，写入磁盘文件
            cin >> file_name;
            fout.open(file_name.c_str());
            if (fout.is_open()) {
                fout << "Output data." << endl;
                fout.close();
                // 写入共享内存
                sem_wait(empty);
                sem_wait(mutex);
                queue->file_names[queue->rear] = file_name;
                queue->rear = (queue->rear + 1) % QUEUE_SIZE;
                sem_post(mutex);
                sem_post(full);
            } else {
                cout << "Error: Failed to open file " << file_name << "." << endl;
            }
        }
    } else {
        // 父进程为打印守护进程
        ifstream fin;
        string file_name;
        while (true) {
            // 从共享内存读取文件名，打印文件内容
            sem_wait(full);
            sem_wait(mutex);
            file_name = queue->file_names[queue->front];
            queue->front = (queue->front + 1) % QUEUE_SIZE;
            sem_post(mutex);
            sem_post(empty);
            fin.open(file_name.c_str());
            if (fin.is_open()) {
                cout << "Printing file " << file_name << "..." << endl;
                string line;
                while (getline(fin, line)) {
                    cout << line << endl;
                }
                fin.close();
            } else {
                cout << "Error: Failed to open file " << file_name << "." << endl;
            }
        }
    }

    // 销毁互斥锁和信号量
    sem_unlink("/mutex");
    sem_unlink("/empty");
    sem_unlink("/full");

    // 脱离共享内存
    shmdt(shm_ptr);

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

    return 0;
}

这段代码实现了一个共享内存环形队列，用于存储输出进程写入的文件名。同时，使用互斥锁和信号量保证了对共享内存的访问互斥，以及输出进程和打印守护进程的同步。具体实现细节可以根据您的具体需求进行修改。