C/C++模拟银行家算法

好的，下面是一个简单的C++代码实现银行家算法模拟：

#include <iostream>
#include <vector>
#include <algorithm>

using namespace std;

// 定义进程结构体
struct Process {
    int id; // 进程id
    vector<int> allocation; // 已分配资源数量
    vector<int> max; // 最大资源需求量
    vector<int> need; // 还需要的资源数量
    bool finished; // 进程是否已完成
};

// 定义系统资源结构体
struct System {
    vector<int> available; // 可用资源数量
};

// 初始化进程信息
void initProcesses(vector<Process>& processes) {
    for (int i = 0; i < processes.size(); i++) {
        cout << "请输入进程" << processes[i].id << "的已分配资源数量：" << endl;
        for (int j = 0; j < processes[i].allocation.size(); j++) {
            cin >> processes[i].allocation[j];
        }
        cout << "请输入进程" << processes[i].id << "的最大资源需求量：" << endl;
        for (int j = 0; j < processes[i].max.size(); j++) {
            cin >> processes[i].max[j];
            processes[i].need[j] = processes[i].max[j] - processes[i].allocation[j]; // 计算还需要的资源数量
        }
    }
}

// 初始化系统资源信息
void initSystem(System& system) {
    cout << "请输入系统可用资源数量：" << endl;
    for (int i = 0; i < system.available.size(); i++) {
        cin >> system.available[i];
    }
}

// 安全性检查
bool isSafe(vector<Process>& processes, System& system) {
    vector<int> work = system.available; // 复制可用资源数量
    vector<bool> finish(processes.size(), false); // 初始化进程完成状态
    int count = 0; // 已完成进程数量

    while (count < processes.size()) {
        bool found = false; // 是否找到满足条件的进程
        for (int i = 0; i < processes.size(); i++) {
            if (!finish[i]) { // 进程未完成
                bool enoughResources = true; // 是否有足够的资源分配给该进程
                for (int j = 0; j < processes[i].need.size(); j++) {
                    if (processes[i].need[j] > work[j]) {
                        enoughResources = false;
                        break;
                    }
                }
                if (enoughResources) { // 有足够的资源分配给该进程
                    finish[i] = true; // 标记进程为已完成
                    count++; // 已完成进程数量+1
                    found = true; // 找到满足条件的进程
                    for (int j = 0; j < processes[i].allocation.size(); j++) {
                        work[j] += processes[i].allocation[j]; // 更新可用资源数量
                    }
                }
            }
        }
        if (!found) { // 没有找到满足条件的进程，系统不安全
            return false;
        }
    }
    return true; // 所有进程都已完成，系统安全
}

// 银行家算法模拟
void bankerAlgorithm(vector<Process>& processes, System& system) {
    while (true) {
        bool found = false; // 是否找到满足条件的进程
        for (int i = 0; i < processes.size(); i++) {
            if (!processes[i].finished) { // 进程未完成
                bool enoughResources = true; // 是否有足够的资源分配给该进程
                for (int j = 0; j < processes[i].need.size(); j++) {
                    if (processes[i].need[j] > system.available[j]) {
                        enoughResources = false;
                        break;
                    }
                }
                if (enoughResources) { // 有足够的资源分配给该进程
                    processes[i].finished = true; // 标记进程为已完成
                    found = true; // 找到满足条件的进程
                    for (int j = 0; j < processes[i].allocation.size(); j++) {
                        system.available[j] += processes[i].allocation[j]; // 更新可用资源数量
                    }
                    cout << "分配资源给进程" << processes[i].id << "，当前可用资源数量为：";
                    for (int j = 0; j < system.available.size(); j++) {
                        cout << system.available[j] << " ";
                    }
                    cout << endl;
                }
            }
        }
        if (!found) { // 没有找到满足条件的进程，退出循环
            break;
        }
    }
    bool allFinished = true; // 是否所有进程都已完成
    for (int i = 0; i < processes.size(); i++) {
        if (!processes[i].finished) {
            allFinished = false;
            break;
        }
    }
    if (allFinished) {
        cout << "所有进程都已完成，安全！" << endl;
    } else {
        cout << "有进程未能完成，不安全！" << endl;
    }
}

int main() {
    int n; // 进程数量
    int m; // 资源数量
    cout << "请输入进程数量和资源数量：" << endl;
    cin >> n >> m;

    vector<Process> processes(n); // 进程数组
    vector<int> available(m); // 可用资源数组
    System system = { available }; // 系统资源

    // 初始化进程信息
    for (int i = 0; i < n; i++) {
        processes[i].id = i;
        processes[i].allocation.resize(m);
        processes[i].max.resize(m);
        processes[i].need.resize(m);
    }
    initProcesses(processes);

    // 初始化系统资源信息
    system.available.resize(m);
    initSystem(system);

    // 进行安全性检查
    if (isSafe(processes, system)) {
        cout << "系统安全！" << endl;
        // 进行银行家算法模拟
        bankerAlgorithm(processes, system);
    } else {
        cout << "系统不安全！" << endl;
    }

    return 0;
}

在上面的代码中，我们通过定义进程结构体和系统资源结构体来存储进程和系统资源的信息。在main函数中，我们先初始化进程信息和系统资源信息，然后进行安全性检查，如果系统安全，就执行银行家算法模拟。

在模拟过程中，我们先检查每个进程是否已完成，如果未完成并且有足够的资源分配给该进程，就分配资源给该进程，并更新可用资源数量。重复执行该过程，直到所有进程都已完成为止。

希望这个代码能够帮到你。如果你有具体的问题或需求，欢迎随时向我提问。