使用c++语言，尽可能简单易懂地完成：首先用随机数生成函数产生一个“指令将要访问的地址序列，有400条；其中 50%的地址访问是顺序执行的，另外 50%就是非顺序执行。且地址在前半部地址空间和后半部地址空间均匀分布。然后将地址序列变换成相应的页地址流（即页访问序列），简化假设为：页面大小为 1K（这里 K 只是表示一个单位，不必是 1024B）； 用户虚存容量为 40K；用户内存容量为 4 个页框到 40 个页框；用户虚存中，每 K 存放 10 条指令。循环运行，使用户内存容量从 4 页框到 40 页框。计算每个内存容量下OPT（最佳置换）、FIFO 和 LRU 算法的命中率，命中率=1-缺页率。

以下是使用C++实现的程序，分别计算OPT、FIFO和LRU算法在不同内存容量下的命中率：

#include <iostream>
#include <cstdlib>
#include <ctime>
#include <vector>
#include <algorithm>
#include <queue>
#include <unordered_map>

using namespace std;

// 生成指令将要访问的地址序列
void generateAddressSequence(vector<int>& addressSequence, int size) {
    srand((unsigned)time(nullptr));
    for (int i = 0; i < size; i++) {
        int address = rand() % 400;
        if (i % 2 == 0) { // 50%的地址访问是顺序执行的
            addressSequence.push_back(address);
        } else { // 50%就是非顺序执行
            if (address < 200) { // 地址在前半部地址空间
                addressSequence.push_back(rand() % 200 + 200);
            } else { // 地址在后半部地址空间
                addressSequence.push_back(rand() % 200);
            }
        }
    }
}

// 将地址序列变换成相应的页地址流
void transformToPageSequence(const vector<int>& addressSequence, vector<int>& pageSequence) {
    for (int i = 0; i < addressSequence.size(); i++) {
        int page = addressSequence[i] / 1; // 页面大小为1K
        pageSequence.push_back(page);
    }
}

// 计算OPT算法的缺页率
double calculateOPTMissRate(const vector<int>& pageSequence, int frameCount) {
    int pageFault = 0; // 页面缺页次数
    unordered_map<int, int> pageMap; // 记录页的最后一次访问时间
    vector<int> frame(frameCount, -1); // 记录内存中的页

    for (int i = 0; i < pageSequence.size(); i++) {
        int page = pageSequence[i];
        if (pageMap.find(page) == pageMap.end()) { // 当前页不在内存中
            if (pageFault < frameCount) { // 内存未满
                frame[pageFault] = page;
                pageMap[page] = i;
            } else { // 内存已满，需要置换页面
                int replacePage = -1;
                int maxTime = -1;
                for (int j = 0; j < frameCount; j++) {
                    int nextPage = frame[j];
                    int nextTime = pageMap[nextPage];
                    if (nextTime == -1) { // 当前页不再被访问，直接置换
                        replacePage = j;
                        break;
                    }
                    if (nextTime > maxTime) { // 寻找最长时间未被访问的页
                        replacePage = j;
                        maxTime = nextTime;
                    }
                }
                frame[replacePage] = page;
                pageMap[page] = i;
            }
            pageFault++;
        } else { // 当前页在内存中，更新最后一次访问时间
            pageMap[page] = i;
        }
    }

    return 1 - (double)pageFault / pageSequence.size();
}

// 计算FIFO算法的缺页率
double calculateFIFOMissRate(const vector<int>& pageSequence, int frameCount) {
    int pageFault = 0; // 页面缺页次数
    queue<int> pageQueue; // 记录内存中的页

    for (int i = 0; i < pageSequence.size(); i++) {
        int page = pageSequence[i];
        if (find(pageQueue.begin(), pageQueue.end(), page) == pageQueue.end()) { // 当前页不在内存中
            if (pageQueue.size() < frameCount) { // 内存未满
                pageQueue.push(page);
            } else { // 内存已满，需要置换页面
                pageQueue.pop();
                pageQueue.push(page);
            }
            pageFault++;
        }
    }

    return 1 - (double)pageFault / pageSequence.size();
}

// 计算LRU算法的缺页率
double calculateLRUMissRate(const vector<int>& pageSequence, int frameCount) {
    int pageFault = 0; // 页面缺页次数
    unordered_map<int, int> pageMap; // 记录页的最后一次访问时间
    vector<int> frame(frameCount, -1); // 记录内存中的页

    for (int i = 0; i < pageSequence.size(); i++) {
        int page = pageSequence[i];
        if (pageMap.find(page) == pageMap.end()) { // 当前页不在内存中
            if (pageFault < frameCount) { // 内存未满
                int index = find(frame.begin(), frame.end(), -1) - frame.begin();
                frame[index] = page;
                pageMap[page] = i;
            } else { // 内存已满，需要置换页面
                int replacePage = -1;
                int minTime = pageSequence.size();
                for (int j = 0; j < frameCount; j++) {
                    int nextPage = frame[j];
                    int nextTime = pageMap[nextPage];
                    if (nextTime < minTime) { // 寻找最久未被访问的页
                        replacePage = j;
                        minTime = nextTime;
                    }
                }
                frame[replacePage] = page;
                pageMap[page] = i;
            }
            pageFault++;
        } else { // 当前页在内存中，更新最后一次访问时间
            pageMap[page] = i;
        }
    }

    return 1 - (double)pageFault / pageSequence.size();
}

int main() {
    vector<int> addressSequence; // 指令将要访问的地址序列
    vector<int> pageSequence; // 页面访问序列
    vector<int> frameCountList = { 4, 5, 6, 7, 8, 9, 10, 15, 20, 25, 30, 35, 40 }; // 不同的内存容量

    generateAddressSequence(addressSequence, 400); // 生成指令将要访问的地址序列
    transformToPageSequence(addressSequence, pageSequence); // 将地址序列变换成相应的页地址流

    for (int i = 0; i < frameCountList.size(); i++) {
        int frameCount = frameCountList[i];
        double optMissRate = calculateOPTMissRate(pageSequence, frameCount); // 计算OPT算法的命中率
        double fifoMissRate = calculateFIFOMissRate(pageSequence, frameCount); // 计算FIFO算法的命中率
        double lruMissRate = calculateLRUMissRate(pageSequence, frameCount); // 计算LRU算法的命中率
        cout << "内存容量为" << frameCount << "页框时，" << endl;
        cout << "OPT算法的命中率为：" << optMissRate << endl;
        cout << "FIFO算法的命中率为：" << fifoMissRate << endl;
        cout << "LRU算法的命中率为：" << lruMissRate << endl;
    }

    return 0;
}

程序首先生成400条指令将要访问的地址序列，然后将其变换成相应的页地址流，接着循环运行，使用户内存容量从4页框到40页框，计算每个内存容量下OPT、FIFO和LRU算法的命中率，最后输出结果。程序中使用了unordered_map和queue标准库，分别实现了OPT和FIFO算法的模拟。