写一个C语言编程模拟一个拥有若干个虚页的进程在给定的若干个实页中运行、并在缺页中断发生时分别使用FIFO、OPT和LRU算法（可用移位寄存器法或堆栈法实现）进行页面置换的情形。 要求： 1.虚页的个数可以事先给定（例如10个），对这些虚页访问的页地址流（其长度可以事先给定，例如20次虚页访问）可以由程序随机产生，也可以事先保存在文件中。 2.要求程序运行时屏幕能显示出置换过程中的状态信息并输出访问结束时的页面命中率（命中率=1-页面失效次数/页地址流长度）。 3.程序应允许通过为该进程分配不同的实页数，来比较几种置换算法的稳定性。 参考测试数据： 页面走向：1,2,3,4,2,1,5,6,2,1,2,3,7,6,3,2,1,2,3,6。分配的内存块数量为3，初始情况下内存块为空。

由于该问题需要涉及到模拟页面置换算法，需要使用到数据结构中的队列和堆栈。我会给出使用堆栈实现的代码，但是需要注意的是，堆栈实现的FIFO算法在实际中并不是常用的算法，因为它无法考虑到页面在内存中的长时间使用情况，容易导致缺页率上升。而LRU和OPT算法更加符合实际使用情况。

以下是使用C语言实现的代码，其中涉及到了堆栈和队列：

#include <stdio.h>
#include <stdlib.h>
#include <time.h>

#define MAX_VPAGE_NUM 10    // 虚页个数
#define MAX_PAGE_SEQ_LEN 20 // 页地址流长度
#define MAX_REAL_PAGE_NUM 5 // 最大实页数

// 页面置换算法类型
typedef enum {
    FIFO = 1,
    OPT = 2,
    LRU = 3
} PageReplaceAlgo;

// 页面节点
typedef struct {
    int vPageNum;      // 虚页号
    int rPageNum;      // 实页号
    int visitTime;     // 最近访问时间
    int inMemory;      // 是否在内存中
} PageNode;

// 页面队列
typedef struct {
    PageNode *nodes;   // 页面节点数组
    int front;         // 队头指针
    int rear;          // 队尾指针
    int size;          // 队列大小
} PageQueue;

// 页面堆栈
typedef struct {
    PageNode *nodes;   // 页面节点数组
    int top;           // 栈顶指针
    int size;          // 栈大小
} PageStack;

// 初始化页面队列
void initPageQueue(PageQueue *queue, int queueSize) {
    queue->nodes = (PageNode *)malloc(sizeof(PageNode) * queueSize);
    queue->front = 0;
    queue->rear = 0;
    queue->size = queueSize;
}

// 入队
void enQueue(PageQueue *queue, PageNode node) {
    if ((queue->rear + 1) % queue->size == queue->front) {
        printf("Queue is full.\n");
        return;
    }
    queue->nodes[queue->rear] = node;
    queue->rear = (queue->rear + 1) % queue->size;
}

// 出队
PageNode deQueue(PageQueue *queue) {
    if (queue->front == queue->rear) {
        printf("Queue is empty.\n");
        exit(0);
    }
    PageNode node = queue->nodes[queue->front];
    queue->front = (queue->front + 1) % queue->size;
    return node;
}

// 初始化页面堆栈
void initPageStack(PageStack *stack, int stackSize) {
    stack->nodes = (PageNode *)malloc(sizeof(PageNode) * stackSize);
    stack->top = -1;
    stack->size = stackSize;
}

// 入栈
void push(PageStack *stack, PageNode node) {
    if (stack->top == stack->size - 1) {
        printf("Stack is full.\n");
        return;
    }
    stack->top++;
    stack->nodes[stack->top] = node;
}

// 出栈
PageNode pop(PageStack *stack) {
    if (stack->top == -1) {
        printf("Stack is empty.\n");
        exit(0);
    }
    PageNode node = stack->nodes[stack->top];
    stack->top--;
    return node;
}

// 生成随机页地址流
void generatePageSeq(int *pageSeq, int pageSeqLen, int vPageNum) {
    srand(time(NULL));
    for (int i = 0; i < pageSeqLen; i++) {
        pageSeq[i] = rand() % vPageNum;
    }
}

// 查找虚页在内存中的位置，未找到返回 -1
int findPageInMemory(PageNode *memory, int realPageNum, int vPageNum) {
    for (int i = 0; i < realPageNum; i++) {
        if (memory[i].vPageNum == vPageNum && memory[i].inMemory == 1) {
            return i;
        }
    }
    return -1;
}

// 查找内存中最久未使用的页面
int findOldestPage(PageNode *memory, int realPageNum) {
    int oldestPage = 0;
    for (int i = 1; i < realPageNum; i++) {
        if (memory[i].visitTime < memory[oldestPage].visitTime) {
            oldestPage = i;
        }
    }
    return oldestPage;
}

// 查找未来最长时间不使用的页面
int findFarthestPage(PageNode *memory, int realPageNum, int *pageSeq, int pageSeqLen, int current) {
    int farthestPage = 0;
    int maxGap = 0;
    for (int i = 0; i < realPageNum; i++) {
        int gap = 0;
        for (int j = current + 1; j < pageSeqLen; j++) {
            if (memory[i].vPageNum == pageSeq[j]) {
                break;
            }
            gap++;
        }
        if (gap > maxGap) {
            maxGap = gap;
            farthestPage = i;
        }
    }
    return farthestPage;
}

// 页面置换
void pageReplacement(PageNode *memory, int realPageNum, PageReplaceAlgo algo, PageNode newNode, PageQueue *queue, PageStack *stack, int *missCount) {
    switch (algo) {
        case FIFO:
            // 先进先出算法
            push(stack, newNode);
            PageNode oldestNode = pop(stack);
            int oldestNodeIndex = findPageInMemory(memory, realPageNum, oldestNode.vPageNum);
            memory[oldestNodeIndex] = newNode;
            enQueue(queue, oldestNode);
            break;
        case OPT:
            // 最佳置换算法
            push(stack, newNode);
            PageNode farthestNode = memory[findFarthestPage(memory, realPageNum, pageSeq, MAX_PAGE_SEQ_LEN, current)];
            int farthestNodeIndex = findPageInMemory(memory, realPageNum, farthestNode.vPageNum);
            memory[farthestNodeIndex] = newNode;
            enQueue(queue, farthestNode);
            break;
        case LRU:
            // 最近最少使用算法
            push(stack, newNode);
            PageNode oldestUsedNode = pop(stack);
            int oldestUsedNodeIndex = findPageInMemory(memory, realPageNum, oldestUsedNode.vPageNum);
            memory[oldestUsedNodeIndex] = newNode;
            break;
        default:
            printf("Invalid algorithm type.\n");
            exit(0);
    }
    (*missCount)++;
}

// 主函数
int main() {
    // 生成随机页地址流
    int pageSeq[MAX_PAGE_SEQ_LEN];
    generatePageSeq(pageSeq, MAX_PAGE_SEQ_LEN, MAX_VPAGE_NUM);

    // 初始化内存
    PageNode memory[MAX_REAL_PAGE_NUM];
    for (int i = 0; i < MAX_REAL_PAGE_NUM; i++) {
        memory[i].vPageNum = -1;
        memory[i].rPageNum = i;
        memory[i].visitTime = 0;
        memory[i].inMemory = 0;
    }

    // 初始化页面队列和堆栈
    PageQueue queue;
    initPageQueue(&queue, MAX_REAL_PAGE_NUM);
    PageStack stack;
    initPageStack(&stack, MAX_REAL_PAGE_NUM);

    // 初始化缺页次数
    int missCount = 0;

    // 依次访问页地址流中的虚页
    for (int current = 0; current < MAX_PAGE_SEQ_LEN; current++) {
        int vPageNum = pageSeq[current];

        // 判断虚页是否在内存中
        int pageIndex = findPageInMemory(memory, MAX_REAL_PAGE_NUM, vPageNum);
        if (pageIndex == -1) {
            // 缺页，进行页面置换
            PageNode newNode;
            newNode.vPageNum = vPageNum;
            newNode.rPageNum = -1;
            newNode.visitTime = current;
            newNode.inMemory = 1;
            pageReplacement(memory, MAX_REAL_PAGE_NUM, LRU, newNode, &queue, &stack, &missCount);
        } else {
            // 命中，更新访问时间
            memory[pageIndex].visitTime = current;
        }

        // 打印当前内存中的页面
        printf("Current memory: ");
        for (int i = 0; i < MAX_REAL_PAGE_NUM; i++) {
            if (memory[i].inMemory == 1) {
                printf("%d ", memory[i].vPageNum);
            }
        }
        printf("\n");
    }

    // 计算命中率
    float hitRate = 1 - (float)missCount / MAX_PAGE_SEQ_LEN;
    printf("Hit rate: %.2f%%\n", hitRate * 100);

    // 释放内存
    free(queue.nodes);
    free(stack.nodes);

    return 0;
}

需要注意的是，在该代码中，FIFO算法使用了堆栈实现，而OPT和LRU算法则没有使用。如果需要使用堆栈实现LRU算法，可以在每次访问页面时将该页面置于栈顶，然后在需要进行页面置换时弹出栈底的页面即可。