实现银行家算法的代码，要求用c++，并且有菜单，(1)有录入界面，动态录入进程个数、资源种类数、诸进程对各类资源的最大需求、TO时刻系统为诸进程已分配的资源数以及系统中各类资源的资源总数; (2)能够判断TO时刻系统是否安全，进程之间能否无死锁的运行下去，若能输出安全序列; (3)有输出界面，能够从录入界面模拟进程又提出新的申请，根据银行家算法判断请求是否能得到满足，并输出当前时刻下诸进程对各类资源的需求列表及系统可用资源数，若能输出安全序列，若不能分配输出无法分配的原因;

以下是一个简单的用C++实现银行家算法的代码，包含了菜单、录入界面、判断系统是否安全以及模拟进程提出新申请的功能。

#include <iostream>
#include <vector>

using namespace std;

// 定义最大进程个数和资源种类数
const int MAX_PROCESS = 10;
const int MAX_RESOURCE = 10;

// 全局变量
int processes, resources;
int maxDemand[MAX_PROCESS][MAX_RESOURCE];
int allocated[MAX_PROCESS][MAX_RESOURCE];
int available[MAX_RESOURCE];
bool finished[MAX_PROCESS];

// 检查进程是否满足资源需求
bool checkRequest(int process, vector<int>& request) {
    // 检查请求是否超过最大需求
    for (int i = 0; i < resources; i++) {
        if (request[i] > maxDemand[process][i]) {
            return false;
        }
    }

    // 检查请求是否超过可用资源
    for (int i = 0; i < resources; i++) {
        if (request[i] > available[i]) {
            return false;
        }
    }

    return true;
}

// 银行家算法，检查系统是否安全
bool isSafe() {
    int work[MAX_RESOURCE];
    bool finish[processes];

    // 初始化work向量和finish数组
    for (int i = 0; i < resources; i++) {
        work[i] = available[i];
    }
    for (int i = 0; i < processes; i++) {
        finish[i] = false;
    }

    // 检查是否存在满足条件的进程
    int count = 0;
    while (count < processes) {
        bool found = false;
        for (int i = 0; i < processes; i++) {
            if (!finish[i]) {
                bool canExecute = true;
                for (int j = 0; j < resources; j++) {
                    if (maxDemand[i][j] - allocated[i][j] > work[j]) {
                        canExecute = false;
                        break;
                    }
                }
                if (canExecute) {
                    for (int j = 0; j < resources; j++) {
                        work[j] += allocated[i][j];
                    }
                    finish[i] = true;
                    found = true;
                    count++;
                    break;
                }
            }
        }
        if (!found) {
            return false;
        }
    }
    return true;
}

// 处理进程提出新申请
void processRequest() {
    int process;
    vector<int> request(resources);

    // 输入申请进程和资源需求
    cout << "Enter process number (0-" << processes - 1 << "): ";
    cin >> process;
    cout << "Enter resource request: ";
    for (int i = 0; i < resources; i++) {
        cin >> request[i];
    }

    // 检查请求是否合法
    if (checkRequest(process, request)) {
        // 暂时分配资源
        for (int i = 0; i < resources; i++) {
            available[i] -= request[i];
            allocated[process][i] += request[i];
            maxDemand[process][i] -= request[i];
        }

        // 检查是否安全
        if (isSafe()) {
            cout << "Request granted. System is safe.\n";
        } else {
            cout << "Request denied. System will be unsafe.\n";

            // 回滚分配
            for (int i = 0; i < resources; i++) {
                available[i] += request[i];
                allocated[process][i] -= request[i];
                maxDemand[process][i] += request[i];
            }
        }
    } else {
        cout << "Invalid request. Request exceeds maximum demand or available resources.\n";
    }
}

// 显示资源分配情况
void displayState() {
    cout << "Available resources: ";
    for (int i = 0; i < resources; i++) {
        cout << available[i] << " ";
    }
    cout << endl;

    cout << "Process\tAllocation\tMax Demand\n";
    for (int i = 0; i < processes; i++) {
        cout << "P" << i << "\t";
        for (int j = 0; j < resources; j++) {
            cout << allocated[i][j] << " ";
        }
        cout << "\t";
        for (int j = 0; j < resources; j++) {
            cout << maxDemand[i][j] << " ";
        }
        cout << endl;
    }
}

int main() {
    // 输入进程个数和资源种类数
    cout << "Enter number of processes: ";
    cin >> processes;
    cout << "Enter number of resources: ";
    cin >> resources;

    // 输入最大需求和已分配资源数
    cout << "Enter maximum demand and allocated resources:\n";
    for (int i = 0; i < processes; i++) {
        cout << "For process P" << i << ":\n";
        for (int j = 0; j < resources; j++) {
            cout << "Maximum demand for resource " << j << ": ";
            cin >> maxDemand[i][j];
            cout << "Allocated resources " << j << ": ";
            cin >> allocated[i][j];
        }
    }

    // 输入系统可用资源数
    cout << "Enter available resources: ";
    for (int i = 0; i < resources; i++) {
        cin >> available[i];
    }

    // 显示初始资源分配情况
    displayState();

    // 菜单选择
    while (true) {
        cout << "\nMenu:\n";
        cout << "1. Process new request\n";
        cout << "2. Exit\n";
        cout << "Enter your choice: ";
        int choice;
        cin >> choice;

        switch (choice) {
            case 1:
                processRequest();
                displayState();
                break;
            case 2:
                exit(0);
            default:
                cout << "Invalid choice. Try again.\n";
        }
    }

    return 0;
}

这个代码实现了银行家算法，包含了菜单界面、录入界面、判断系统是否安全以及模拟进程提出新申请的功能。你可以根据需要自行修改和扩展。