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

好的，我来给您提供一份假脱机打印系统的代码，满足您的要求。

【注】由于CSDN平台的限制，本代码中的中文注释可能会出现乱码，请以英文注释为准。

#include <windows.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

// 定义共享内存大小
#define BUFFER_SIZE 1024

// 定义环形队列的大小
#define QUEUE_SIZE 10

// 定义共享内存结构体
typedef struct _SHARED_DATA {
    // 环形队列头指针
    int head;

    // 环形队列尾指针
    int tail;

    // 互斥量
    HANDLE mutex;

    // 信号量
    HANDLE semaphore;

    // 环形队列，存储文件名
    char queue[QUEUE_SIZE][MAX_PATH];
} SHARED_DATA;

// 获取共享内存指针
SHARED_DATA* GetSharedData()
{
    // 定义共享内存指针
    SHARED_DATA* pData = NULL;

    // 创建共享内存
    HANDLE hMapping = CreateFileMapping(INVALID_HANDLE_VALUE, NULL, PAGE_READWRITE, 0, BUFFER_SIZE, "Local\\PrintSystem");

    // 判断共享内存是否创建成功
    if (hMapping != NULL)
    {
        // 映射共享内存
        pData = (SHARED_DATA*)MapViewOfFile(hMapping, FILE_MAP_ALL_ACCESS, 0, 0, BUFFER_SIZE);

        // 判断共享内存是否映射成功
        if (pData == NULL)
        {
            printf("MapViewOfFile failed!\n");
        }
    }
    else
    {
        printf("CreateFileMapping failed!\n");
    }

    return pData;
}

// 释放共享内存
void ReleaseSharedData(SHARED_DATA* pData)
{
    // 释放互斥量
    CloseHandle(pData->mutex);

    // 释放信号量
    CloseHandle(pData->semaphore);

    // 释放共享内存
    UnmapViewOfFile(pData);
}

// 输出进程
void OutputProcess()
{
    // 获取共享内存指针
    SHARED_DATA* pData = GetSharedData();

    // 判断共享内存是否获取成功
    if (pData != NULL)
    {
        // 输出进程循环执行
        while (true)
        {
            // 生成一个随机文件名
            char fileName[MAX_PATH];
            sprintf(fileName, "output_%d.txt", rand());

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

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

            // 关闭文件
            fclose(fp);

            // 获取互斥量
            WaitForSingleObject(pData->mutex, INFINITE);

            // 将文件名写入环形队列
            strcpy(pData->queue[pData->tail], fileName);

            // 更新队列尾指针
            pData->tail = (pData->tail + 1) % QUEUE_SIZE;

            // 释放互斥量
            ReleaseMutex(pData->mutex);

            // 发送信号量给打印守护进程
            ReleaseSemaphore(pData->semaphore, 1, NULL);

            // 休眠一段时间
            Sleep(1000);
        }

        // 释放共享内存
        ReleaseSharedData(pData);
    }
}

// 打印守护进程
void PrintProcess()
{
    // 获取共享内存指针
    SHARED_DATA* pData = GetSharedData();

    // 判断共享内存是否获取成功
    if (pData != NULL)
    {
        // 打印守护进程循环执行
        while (true)
        {
            // 等待信号量
            WaitForSingleObject(pData->semaphore, INFINITE);

            // 获取互斥量
            WaitForSingleObject(pData->mutex, INFINITE);

            // 读取队列头部文件名
            char fileName[MAX_PATH];
            strcpy(fileName, pData->queue[pData->head]);

            // 更新队列头指针
            pData->head = (pData->head + 1) % QUEUE_SIZE;

            // 释放互斥量
            ReleaseMutex(pData->mutex);

            // 打开文件
            FILE* fp = fopen(fileName, "r");

            // 判断文件是否打开成功
            if (fp != NULL)
            {
                // 读取文件内容并输出到屏幕
                char buffer[1024];
                while (fgets(buffer, sizeof(buffer), fp))
                {
                    printf("%s", buffer);
                }

                // 关闭文件
                fclose(fp);
            }

            // 删除文件
            remove(fileName);
        }

        // 释放共享内存
        ReleaseSharedData(pData);
    }
}

int main()
{
    // 初始化随机数种子
    srand(GetTickCount());

    // 获取共享内存指针
    SHARED_DATA* pData = GetSharedData();

    // 判断共享内存是否获取成功
    if (pData != NULL)
    {
        // 初始化共享内存
        pData->head = 0;
        pData->tail = 0;
        pData->mutex = CreateMutex(NULL, FALSE, "Local\\PrintSystemMutex");
        pData->semaphore = CreateSemaphore(NULL, 0, QUEUE_SIZE, "Local\\PrintSystemSemaphore");

        // 判断互斥量和信号量是否创建成功
        if (pData->mutex == NULL || pData->semaphore == NULL)
        {
            printf("CreateMutex or CreateSemaphore failed!\n");

            // 释放共享内存
            ReleaseSharedData(pData);

            return -1;
        }
    }
    else
    {
        return -1;
    }

    // 创建输出进程和打印守护进程
    HANDLE hOutput = CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE)OutputProcess, NULL, 0, NULL);
    HANDLE hPrint = CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE)PrintProcess, NULL, 0, NULL);

    // 等待进程结束
    WaitForSingleObject(hOutput, INFINITE);
    WaitForSingleObject(hPrint, INFINITE);

    // 关闭进程句柄
    CloseHandle(hOutput);
    CloseHandle(hPrint);

    return 0;
}

以上是一份简单的假脱机打印系统代码，具体实现还需要根据您的需求进行调整。希望对您有所帮助。