如何在二维结构体中删除符合条件的特工并动态调整数组大小

任务背景 #

• 需完成绝密机构的特工退休统计，涉及两个结构体：
  • Agency：包含string title、int min_missions、int agentCount、Spy* agents
  • Spy：包含string name、string speciality、int completed_missions、bool is_private，特工专长仅三类："Diplomacy""SpecOps""DarkMistery"
• 退休规则：
  1. 已完成任务数需超过机构最低任务数
  2. "SpecOps"特工的最低任务数减2
  3. "DarkMistery"特工的最低任务数翻倍
  4. is_private为true的特工无法退休

现有问题 #

已实现符合退休条件的特工判断，但不知道如何在动态分配的结构体数组中删除符合退休条件的特工（调整数组大小），同时需要通过修改agc[i].agentCount来更新特工数量，尝试过delete但不会在二维结构中正确使用。

现有代码 #

#include "iostream"
#include "string"
using namespace std;

struct Spy { //The Spy structure
    string name;
    string speciality;
    int missions;
    bool is_private;
};

struct Agency { //The agency structure
    string title;
    int min_missions;
    int agentCount;
    Spy* agnt;
};

istream& operator >> (istream& is, Spy& sp) { //The operator to enter the values of spy
    is >> sp.name >> sp.speciality >> sp.missions >> sp.is_private;
    return is;
}

istream& operator >> (istream& is, Agency& agc) {//To enter the values of Agency
    is >> agc.title >> agc.min_missions >> agc.agentCount;
    return is;
}


int main() {
    int N; cout << "Enter the number of agencies: \n";
    cin >> N;
    Agency* agc = new Agency[N];
    for (int i = 0; i < N; ++i) {
        cin >> agc[i];
        agc[i].agnt = new Spy[agc[i].agentCount];
        for (int j = 0; j < agc[i].agentCount; ++j) {
            cin >> agc[i].agnt[j];
        }
    }

    for (int i = 0; i < N; ++i) {
        int sum = 0;
        int count = 0;
        for (int j = 0; j < agc[i].agentCount; ++j) {
            if (agc[i].agnt[j].is_private) {
                continue;
            }
            else {
                if (agc[i].agnt[j].speciality == "DarkMistery") {
                    count = (agc[i].min_missions * 2);
                }
                else if (agc[i].agnt[j].speciality == "SpecOps") {
                    count = (agc[i].min_missions - 2);
                }
                else {
                    count = agc[i].min_missions;
                }
                if (agc[i].agnt[j].missions > count) {
                    sum++;
                } else {
                    continue;
                }
            }
        }
    }
}

解决方案 #

核心思路 #

动态数组无法直接删除元素，需通过"创建新数组+保留目标元素+替换原数组"的方式实现调整：

1. 统计每个机构中不需要退休的特工数量
2. 分配对应大小的新数组，将需保留的特工复制进去
3. 释放原数组内存，更新机构的特工数组指针和数量
4. 同步统计各机构退休人数，找出退休人数最多的机构

修改后的完整代码 #

#include "iostream"
#include "string"
using namespace std;

struct Spy {
    string name;
    string speciality;
    int missions;
    bool is_private;
};

struct Agency {
    string title;
    int min_missions;
    int agentCount;
    Spy* agnt;
};

istream& operator >> (istream& is, Spy& sp) {
    is >> sp.name >> sp.speciality >> sp.missions >> sp.is_private;
    return is;
}

istream& operator >> (istream& is, Agency& agc) {
    is >> agc.title >> agc.min_missions >> agc.agentCount;
    return is;
}

// 判断特工是否符合退休条件
bool canRetire(const Spy& spy, int agencyMinMissions) {
    if (spy.is_private) return false;
    
    int requiredMissions;
    if (spy.speciality == "DarkMistery") {
        requiredMissions = agencyMinMissions * 2;
    } else if (spy.speciality == "SpecOps") {
        requiredMissions = agencyMinMissions - 2;
        // 防止最低任务数为负数
        if (requiredMissions < 0) requiredMissions = 0;
    } else {
        requiredMissions = agencyMinMissions;
    }
    
    return spy.missions > requiredMissions;
}

int main() {
    int N; cout << "Enter the number of agencies: \n";
    cin >> N;
    Agency* agc = new Agency[N];
    
    // 输入机构和特工数据
    for (int i = 0; i < N; ++i) {
        cin >> agc[i];
        agc[i].agnt = new Spy[agc[i].agentCount];
        for (int j = 0; j < agc[i].agentCount; ++j) {
            cin >> agc[i].agnt[j];
        }
    }
    
    int maxRetired = -1;
    string maxAgencyTitle;
    
    // 处理每个机构
    for (int i = 0; i < N; ++i) {
        int remainingAgents = 0;
        // 统计需保留的特工数量
        for (int j = 0; j < agc[i].agentCount; ++j) {
            if (!canRetire(agc[i].agnt[j], agc[i].min_missions)) {
                remainingAgents++;
            }
        }
        
        // 更新退休人数最多的机构
        int retiredCount = agc[i].agentCount - remainingAgents;
        if (retiredCount > maxRetired) {
            maxRetired = retiredCount;
            maxAgencyTitle = agc[i].title;
        }
        
        // 创建新数组并复制保留的特工
        Spy* newAgents = new Spy[remainingAgents];
        int newIndex = 0;
        for (int j = 0; j < agc[i].agentCount; ++j) {
            if (!canRetire(agc[i].agnt[j], agc[i].min_missions)) {
                newAgents[newIndex++] = agc[i].agnt[j];
            }
        }
        
        // 释放原数组，更新机构数据
        delete[] agc[i].agnt;
        agc[i].agnt = newAgents;
        agc[i].agentCount = remainingAgents;
    }
    
    // 输出结果
    cout << "Agency with most retired agents: " << maxAgencyTitle << endl;
    cout << "Number of retired agents: " << maxRetired << endl;
    
    // 释放所有动态分配的内存
    for (int i = 0; i < N; ++i) {
        delete[] agc[i].agnt;
    }
    delete[] agc;
    
    return 0;
}

关键说明 #

• 封装canRetire函数，统一退休判断逻辑，提升代码可读性
• 增加SpecOps特工最低任务数的负数防护，避免不合理要求
• 完成动态数组调整的同时，实现了"找出退休特工最多机构"的核心目标
• 最后释放所有动态分配的内存，避免内存泄漏

内容的提问来源于stack exchange，提问作者Damir