如何在C++中向二维数组插入可变数量数据及文件数据拆分

嘿，你已经迈出了第一步，我来帮你把数据插入的逻辑补全。首先咱们先明确下需求：input.txt里的内容是成对的(ID, 元素值)，咱们要把唯一ID存到第一个数组，每个ID对应的所有元素值存到第二个数组（因为每个ID的元素数量不一样，所以第二个数组得是二维动态数组）。

我给你两种实现思路，你可以根据自己的需求选：

方法一：用STL容器过渡（推荐，代码简洁不易出错） #

这种方式先用unordered_map和vector临时分组数据，再转成你需要的动态数组，不用手动统计，省很多事：

#include <iostream>
#include <fstream>
#include <vector>
#include <unordered_map>

using namespace std;

int main() {
    // 临时容器：key是ID，value是该ID对应的所有元素
    unordered_map<int, vector<int>> id_element_map;
    int current_id, current_element;
    ifstream input_file("input.txt");

    // 第一遍读取：把所有数据按ID分组
    while (input_file >> current_id >> current_element) {
        id_element_map[current_id].push_back(current_element);
    }
    input_file.close();

    // 准备动态分配内存
    int total_unique_ids = id_element_map.size();
    // 第一个数组：存储所有唯一ID
    int* id_array = new int[total_unique_ids];
    // 第二个数组：二维动态数组，每个子数组对应一个ID的元素
    int** element_arrays = new int*[total_unique_ids];
    // 额外存一个数组记录每个ID的元素数量，方便后续遍历和释放内存
    int* element_counts = new int[total_unique_ids];

    // 把临时容器里的数据复制到动态数组
    int index = 0;
    for (auto& entry : id_element_map) {
        int id = entry.first;
        vector<int>& elements = entry.second;

        id_array[index] = id;
        element_counts[index] = elements.size();
        // 为当前ID的元素数组分配内存
        element_arrays[index] = new int[elements.size()];
        // 复制元素
        for (int i = 0; i < elements.size(); ++i) {
            element_arrays[index][i] = elements[i];
        }
        index++;
    }

    // 验证输出（可以删掉）
    cout << "ID数组：";
    for (int i = 0; i < total_unique_ids; ++i) {
        cout << id_array[i] << " ";
    }
    cout << "\n对应元素数组：\n";
    for (int i = 0; i < total_unique_ids; ++i) {
        cout << "ID " << id_array[i] << ": ";
        for (int j = 0; j < element_counts[i]; ++j) {
            cout << element_arrays[i][j] << " ";
        }
        cout << "\n";
    }

    // 务必释放动态内存，避免内存泄漏
    for (int i = 0; i < total_unique_ids; ++i) {
        delete[] element_arrays[i];
    }
    delete[] element_arrays;
    delete[] id_array;
    delete[] element_counts;

    return 0;
}

代码解释： #

1. 用unordered_map自动帮咱们分组ID和对应的元素，不用手动判断ID是否重复；
2. 遍历map就能得到唯一ID的数量，然后分配对应的动态数组；
3. 最后一定要记得释放动态分配的内存，不然会造成内存泄漏。

方法二：纯手动统计（不用STL容器） #

如果你不想用STL，也可以手动统计唯一ID和元素数量，再填充数据：

#include <iostream>
#include <fstream>

using namespace std;

int main() {
    int current_id, current_element;
    ifstream input_file("input.txt");
    if (!input_file.is_open()) {
        cerr << "无法打开input.txt文件！" << endl;
        return 1;
    }

    // 第一步：把所有数据读到临时数组里（假设数据量不会太大，也可以用动态数组）
    const int MAX_DATA = 1000;
    int temp_ids[MAX_DATA];
    int temp_elements[MAX_DATA];
    int data_count = 0;
    while (input_file >> current_id >> current_element) {
        temp_ids[data_count] = current_id;
        temp_elements[data_count] = current_element;
        data_count++;
    }
    input_file.close();

    // 第二步：统计唯一ID的数量和每个ID的元素个数
    int total_unique_ids = 0;
    int unique_ids[MAX_DATA];
    int element_counts[MAX_DATA] = {0};
    for (int i = 0; i < data_count; ++i) {
        bool is_new_id = true;
        // 检查当前ID是否已经在unique_ids里
        for (int j = 0; j < total_unique_ids; ++j) {
            if (temp_ids[i] == unique_ids[j]) {
                is_new_id = false;
                element_counts[j]++;
                break;
            }
        }
        if (is_new_id) {
            unique_ids[total_unique_ids] = temp_ids[i];
            element_counts[total_unique_ids] = 1;
            total_unique_ids++;
        }
    }

    // 第三步：动态分配数组
    int* id_array = new int[total_unique_ids];
    int** element_arrays = new int*[total_unique_ids];
    // 先把唯一ID复制到id_array，同时为每个元素数组分配内存
    for (int i = 0; i < total_unique_ids; ++i) {
        id_array[i] = unique_ids[i];
        element_arrays[i] = new int[element_counts[i]];
        // 重置计数器，用来填充元素数组
        element_counts[i] = 0;
    }

    // 第四步：填充元素数组
    for (int i = 0; i < data_count; ++i) {
        int id = temp_ids[i];
        int elem = temp_elements[i];
        // 找到当前ID在id_array中的索引
        for (int j = 0; j < total_unique_ids; ++j) {
            if (id_array[j] == id) {
                element_arrays[j][element_counts[j]] = elem;
                element_counts[j]++;
                break;
            }
        }
    }

    // 验证输出（可以删掉）
    cout << "ID数组：";
    for (int i = 0; i < total_unique_ids; ++i) {
        cout << id_array[i] << " ";
    }
    cout << "\n对应元素数组：\n";
    for (int i = 0; i < total_unique_ids; ++i) {
        cout << "ID " << id_array[i] << ": ";
        // 重新统计当前ID的元素数量（因为之前重置了element_counts）
        int cnt = 0;
        for (int k = 0; k < data_count; ++k) {
            if (temp_ids[k] == id_array[i]) cnt++;
        }
        for (int j = 0; j < cnt; ++j) {
            cout << element_arrays[i][j] << " ";
        }
        cout << "\n";
    }

    // 释放内存
    for (int i = 0; i < total_unique_ids; ++i) {
        delete[] element_arrays[i];
    }
    delete[] element_arrays;
    delete[] id_array;

    return 0;
}

代码解释： #

1. 先把所有数据读到临时数组，避免重复打开文件；
2. 两次遍历临时数组：第一次统计唯一ID和元素数量，第二次填充动态数组；
3. 这种方式代码更繁琐，但完全不用STL容器，适合需要手动管理内存的场景。

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