银行家算法（安全性检测及资源申请分配）c++

以下是一个简单的基于C++的银行家算法实现，包括安全性检测和资源申请分配两个部分。

#include <iostream>
#include <vector>
using namespace std;

// 可用资源向量
vector<int> available;
// 最大需求矩阵
vector<vector<int>> max_need;
// 已分配矩阵
vector<vector<int>> allocation;
// 需求矩阵
vector<vector<int>> need;
// 安全序列
vector<int> safe_sequence;

// 检查当前状态是否安全
bool is_safe() {
    // 初始化工作
    vector<int> work(available); // 工作向量
    vector<bool> finish(need.size(), false); // 完成向量
    safe_sequence.clear(); // 清空安全序列

    // 循环判断是否有可以满足的进程
    int count = 0;
    while (count < need.size()) {
        bool found = false; // 是否找到一个可以满足的进程
        for (int i = 0; i < need.size(); i++) {
            if (!finish[i]) {
                bool can_satisfy = true;
                for (int j = 0; j < available.size(); j++) {
                    if (need[i][j] > work[j]) {
                        can_satisfy = false;
                        break;
                    }
                }
                if (can_satisfy) {
                    found = true;
                    finish[i] = true;
                    safe_sequence.push_back(i);
                    for (int j = 0; j < available.size(); j++) {
                        work[j] += allocation[i][j];
                    }
                    count++;
                }
            }
        }
        if (!found) {
            return false; // 没有找到可满足的进程，说明不安全
        }
    }
    return true;
}

// 分配资源
bool allocate_resources(int process_id, vector<int> resources) {
    // 检查是否有足够的资源可用
    for (int i = 0; i < available.size(); i++) {
        if (resources[i] > available[i]) {
            return false; // 没有足够的资源可用
        }
    }

    // 检查是否满足需求
    for (int i = 0; i < available.size(); i++) {
        if (resources[i] > need[process_id][i]) {
            return false; // 请求的资源超过了进程的最大需求
        }
    }

    // 分配资源
    for (int i = 0; i < available.size(); i++) {
        available[i] -= resources[i];
        allocation[process_id][i] += resources[i];
        need[process_id][i] -= resources[i];
    }

    // 检查安全性
    if (is_safe()) {
        return true; // 安全，分配成功
    }
    else {
        // 不安全，恢复原状态
        for (int i = 0; i < available.size(); i++) {
            available[i] += resources[i];
            allocation[process_id][i] -= resources[i];
            need[process_id][i] += resources[i];
        }
        return false; // 分配失败
    }
}

int main() {
    // 初始化资源向量和矩阵
    available = { 3, 3, 2 };
    max_need = {
        {7, 5, 3},
        {3, 2, 2},
        {9, 0, 2},
        {2, 2, 2},
        {4, 3, 3}
    };
    allocation = {
        {0, 1, 0},
        {2, 0, 0},
        {3, 0, 2},
        {2, 1, 1},
        {0, 0, 2}
    };
    need.resize(max_need.size());
    for (int i = 0; i < need.size(); i++) {
        need[i].resize(available.size());
        for (int j = 0; j < available.size(); j++) {
            need[i][j] = max_need[i][j] - allocation[i][j];
        }
    }

    // 测试安全性检测
    if (is_safe()) {
        cout << "当前状态安全" << endl;
    }
    else {
        cout << "当前状态不安全" << endl;
    }

    // 测试资源分配
    vector<int> resources = { 0, 0, 1 };
    int process_id = 1;
    if (allocate_resources(process_id, resources)) {
        cout << "分配成功，安全序列为：";
        for (int i = 0; i < safe_sequence.size(); i++) {
            cout << safe_sequence[i] << " ";
        }
        cout << endl;
    }
    else {
        cout << "分配失败" << endl;
    }

    return 0;
}

以上代码仅供参考，实际应用中可能需要根据具体需求进行修改。