参考银行家算法，利用高级语言（C、C++、C#、Java均可）编写一个资源分配系统，该系统包括如下功能： 1、资源分配 2、安全性检查 3、添加新资源 4、添加新进程 5、删除资源 6、修改资源 7、退出系统

好的，我可以为您编写一个简单的资源分配系统，以下是代码：

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

// 定义进程结构体
struct Process {
    int id;             // 进程ID
    vector<int> alloc;  // 进程已分配的资源数
    vector<int> need;   // 进程还需要的资源数
    bool finish;        // 进程是否已完成
};

// 定义资源结构体
struct Resource {
    int id;         // 资源ID
    int maxNum;     // 资源的最大数量
    int nowNum;     // 资源的当前数量
};

vector<Process> processes;  // 存储所有进程
vector<Resource> resources;  // 存储所有资源

// 初始化进程和资源
void init() {
    // 初始化进程
    int pNum, rNum;
    cout << "请输入进程数和资源数：" << endl;
    cin >> pNum >> rNum;
    for (int i = 0; i < pNum; i++) {
        Process p;
        p.id = i;
        p.finish = false;
        cout << "请输入进程" << i << "已分配的资源数：" << endl;
        for (int j = 0; j < rNum; j++) {
            int num;
            cin >> num;
            p.alloc.push_back(num);
        }
        cout << "请输入进程" << i << "还需要的资源数：" << endl;
        for (int j = 0; j < rNum; j++) {
            int num;
            cin >> num;
            p.need.push_back(num);
        }
        processes.push_back(p);
    }
    // 初始化资源
    for (int i = 0; i < rNum; i++) {
        Resource r;
        r.id = i;
        cout << "请输入资源" << i << "的最大数量：" << endl;
        cin >> r.maxNum;
        r.nowNum = r.maxNum;
        resources.push_back(r);
    }
}

// 资源分配函数
bool allocate(int pId, vector<int> request) {
    // 检查请求是否合法
    for (int i = 0; i < request.size(); i++) {
        if (request[i] > processes[pId].need[i] || request[i] > resources[i].nowNum) {
            return false;
        }
    }
    // 分配资源
    for (int i = 0; i < request.size(); i++) {
        processes[pId].alloc[i] += request[i];
        processes[pId].need[i] -= request[i];
        resources[i].nowNum -= request[i];
    }
    // 检查是否安全
    vector<int> work;
    for (int i = 0; i < resources.size(); i++) {
        work.push_back(resources[i].nowNum);
    }
    vector<bool> finish(processes.size(), false);
    int count = 0;
    while (count < processes.size()) {
        bool flag = false;
        for (int i = 0; i < processes.size(); i++) {
            if (!finish[i]) {
                bool ok = true;
                for (int j = 0; j < resources.size(); j++) {
                    if (processes[i].need[j] > work[j]) {
                        ok = false;
                        break;
                    }
                }
                if (ok) {
                    flag = true;
                    finish[i] = true;
                    count++;
                    for (int j = 0; j < resources.size(); j++) {
                        work[j] += processes[i].alloc[j];
                    }
                }
            }
        }
        if (!flag) {
            for (int i = 0; i < request.size(); i++) {
                processes[pId].alloc[i] -= request[i];
                processes[pId].need[i] += request[i];
                resources[i].nowNum += request[i];
            }
            return false;
        }
    }
    return true;
}

// 安全性检查函数
bool checkSafe() {
    vector<int> work;
    for (int i = 0; i < resources.size(); i++) {
        work.push_back(resources[i].nowNum);
    }
    vector<bool> finish(processes.size(), false);
    int count = 0;
    while (count < processes.size()) {
        bool flag = false;
        for (int i = 0; i < processes.size(); i++) {
            if (!finish[i]) {
                bool ok = true;
                for (int j = 0; j < resources.size(); j++) {
                    if (processes[i].need[j] > work[j]) {
                        ok = false;
                        break;
                    }
                }
                if (ok) {
                    flag = true;
                    finish[i] = true;
                    count++;
                    for (int j = 0; j < resources.size(); j++) {
                        work[j] += processes[i].alloc[j];
                    }
                }
            }
        }
        if (!flag) {
            return false;
        }
    }
    return true;
}

// 添加新资源函数
void addResource() {
    Resource r;
    r.id = resources.size();
    cout << "请输入新资源的最大数量：" << endl;
    cin >> r.maxNum;
    r.nowNum = r.maxNum;
    resources.push_back(r);
}

// 添加新进程函数
void addProcess() {
    Process p;
    p.id = processes.size();
    p.finish = false;
    cout << "请输入进程已分配的资源数：" << endl;
    for (int i = 0; i < resources.size(); i++) {
        int num;
        cin >> num;
        p.alloc.push_back(num);
    }
    cout << "请输入进程还需要的资源数：" << endl;
    for (int i = 0; i < resources.size(); i++) {
        int num;
        cin >> num;
        p.need.push_back(num);
    }
    processes.push_back(p);
}

// 删除资源函数
void deleteResource() {
    int id;
    cout << "请输入要删除的资源ID：" << endl;
    cin >> id;
    resources.erase(resources.begin() + id);
    for (int i = id; i < resources.size(); i++) {
        resources[i].id--;
    }
    for (int i = 0; i < processes.size(); i++) {
        processes[i].alloc.erase(processes[i].alloc.begin() + id);
        processes[i].need.erase(processes[i].need.begin() + id);
    }
}

// 修改资源函数
void modifyResource() {
    int id;
    cout << "请输入要修改的资源ID：" << endl;
    cin >> id;
    cout << "请输入新的最大数量：" << endl;
    cin >> resources[id].maxNum;
    resources[id].nowNum = resources[id].maxNum;
}

int main() {
    init();
    while (true) {
        cout << endl << "请输入要执行的操作：" << endl;
        cout << "1. 资源分配" << endl;
        cout << "2. 安全性检查" << endl;
        cout << "3. 添加新资源" << endl;
        cout << "4. 添加新进程" << endl;
        cout << "5. 删除资源" << endl;
        cout << "6. 修改资源" << endl;
        cout << "7. 退出系统" << endl;
        int op;
        cin >> op;
        switch (op) {
            case 1: {
                int pId;
                cout << "请输入要分配资源的进程ID：" << endl;
                cin >> pId;
                vector<int> request;
                cout << "请输入要分配的资源数：" << endl;
                for (int i = 0; i < resources.size(); i++) {
                    int num;
                    cin >> num;
                    request.push_back(num);
                }
                if (allocate(pId, request)) {
                    cout << "分配成功！" << endl;
                } else {
                    cout << "分配失败！" << endl;
                }
                break;
            }
            case 2: {
                if (checkSafe()) {
                    cout << "系统安全！" << endl;
                } else {
                    cout << "系统不安全！" << endl;
                }
                break;
            }
            case 3: {
                addResource();
                cout << "添加成功！" << endl;
                break;
            }
            case 4: {
                addProcess();
                cout << "添加成功！" << endl;
                break;
            }
            case 5: {
                deleteResource();
                cout << "删除成功！" << endl;
                break;
            }
            case 6: {
                modifyResource();
                cout << "修改成功！" << endl;
                break;
            }
            case 7: {
                return 0;
            }
            default: {
                cout << "无效操作！" << endl;
                break;
            }
        }
    }
    return 0;
}

这个系统中，我们用两个结构体来分别存储进程和资源的信息。在初始化时，用户需要输入进程数和资源数，并分别输入每个进程已分配的资源数和还需要的资源数，以及每种资源的最大数量。然后，用户可以执行资源分配、安全性检查、添加新资源、添加新进程、删除资源、修改资源等操作。其中，资源分配会先检查请求是否合法，然后尝试分配资源，若分配后系统仍安全，则分配成功；否则，分配失败。安全性检查会检查当前系统是否安全。添加新资源和添加新进程会让用户输入相应的信息，然后添加到系统中。删除资源会删除相应的资源，并将后面的资源ID减去1，同时还需要删除所有进程中对应的资源数和需求。修改资源会让用户输入新的最大数量，并将当前数量更新为最大数量。最后，用户可以选择退出系统。