C++ 从文件读入对象？

我有一个以下格式的文件：

3 // num of tasks in taskset1
1 2 3 //priority for each task
10 20 30  //exec time, deadline , period
23 34.5 45
23 56 98
4 // num of tasks in taskset2
1 2 4 3//priority for each task
10 20 30  //exec time, deadline , period
23 34.5 45
23 56 98
34 54 100
......

我需要将文本文件直接读入结构对象

taskset

struct tasks
{
    double wcet;
    double deadline;
    double period;
    int priority;
};

struct tasksets
{
    tasks task[100];
    double num_tasks;
} taskset[100];

我将内容存储在一个数组中，然后存储到工作正常的对象中。但是由于我的文件太大，我的程序被杀死了。我不需要使用巨大的阵列。而不是100个不同的对象，只需将一个对象用于

任务集

。有什么建议吗

int main(int argc, char* argv[])
{
    double aa[1000][1000];
    int u = 0;
    int v = 0;
    int i = 0;
    int j = 0;
    int k = 0;
    string temp; // a temporary variable used to store string data
    vector<vector<string>> tokens;
    while (getline(cin, temp))
    {
        v = 0;
        istringstream iss(temp);

        vector<string> tokens_in_line;

        while (iss >> temp)
        {
            double temp1 = atof(temp.c_str());
            aa[u][v] = temp1;
            v++;
            tokens_in_line.push_back(temp);
        }
        u++;
        if (!tokens_in_line.empty())
        {
            tokens.push_back(tokens_in_line);
        }
    }
    cout << "Execution started" << endl;
    for (i = 0; i < u; i = i + j)
    {
        cout << "Task set #" << setnum << endl;
        taskset[setnum].num_tasks = aa[i][0];
        cout << "Number of tasks: " << taskset[setnum].num_tasks << endl;

        for (k = 0; k < taskset[setnum].num_tasks; k++)
        {
            taskset[setnum].task[k].priority = aa[i + 1][k];
            taskset[setnum].task[k].wcet = aa[i + 2 + k][0];
            taskset[setnum].task[k].deadline = aa[i + 2 + k][1];
            taskset[setnum].task[k].period = aa[i + 2 + k][2];
            cout << "Task " << k + 1 << ":";
            cout << " Priority : " << taskset[setnum].task[k].priority;
            cout << " WCET : " << taskset[setnum].task[k].wcet;
            cout << " Deadline : " << taskset[setnum].task[k].deadline;
            cout << " Period : " << taskset[setnum].task[k].period << endl;
        }
        j = k + 2;
        setnum++;
    }
    return 0;
}

intmain（intargc，char*argv[]）
{
双aa[1000][1000]；
int u=0；
int v=0；
int i=0；
int j=0；
int k=0；
string temp；//用于存储字符串数据的临时变量
向量标记；
while（getline（cin，temp））
{
v=0；
istringstream iss（温度）；
向量标记在向量行中；
而（iss>>温度）
{
双temp1=atof（temp.c_str（））；
aa[u][v]=temp1；
v++；
令牌在队列中。推回（临时）；
}
u++；
如果（！tokens_in_line.empty（））
{
代币。推回（代币排成一行）；
}
}
cout是的，你可以用操作符>>直接读入类的变量。使用getline读入每个变量。我之前使用的代码如下所示，让你看到它是如何完成的。基本上，你想创建一个包含需要读入的变量的类，然后你想在类或main中实例化它，无论你在做什么d读取文件，然后以这种方式添加每个变量。参见下文，其中p是带有变量的实例类

 string STRING;
    string floor;
    string toFloor;
    ifstream infile;
    infile.open("passenger requests.txt");

    if (!infile)
    {
        cout << "no good file failed! \n" << endl;
    }

    while (infile.good())
    {
        for (int i = 0; i < 49; ++i)
        {
            getline(infile, STRING);
            //Saves the line in STRING.
            infile >> p[i].time;

            getline(infile, floor, ',');
            infile >> p[i].fromFloor;
            getline(infile, toFloor, ',');
            infile >> p[i].toFloor;
        }

    }

    infile.close();
}

字符串；
串层；
串地板；
河流充填；
infle.open（“passenger requests.txt”）；
如果（！infle）
{
coutp[i].时间；
getline（填充，楼层，'，'）；
infle>>p[i].fromFloor；
getline（填充，托福楼，'，'）；
infle>>p[i].地板；
}
}
infle.close（）；
}
正如Josh已经指出的，您可以直接将令牌读入变量，而不是将它们存储在
aa
中。顺便说一句，
aa
作为数组的双数组对于整数令牌来说不是一个好的选择

关于使用固定大小的数组和因太大的输入集而导致程序崩溃，我会选择
std:：list
或
std:：vector
作为
任务集
，并根据需要添加新对象

最后，您的代码没有按照提供的方式编译，我必须添加一个setnum声明和必要的头。
我在您的格式中看到的主要问题是，您必须先读取taskset中所有任务的所有优先级，然后才能真正读取任务，如果您可以将格式更改为将每个任务的优先级存储在其他详细信息所在的同一行，则会更好，无论如何，这是一个比原始版本占用更少内存的版本：

struct task {
    double wcet;
    double deadline;
    double period;
    int priority;
};

int main(int, char**) {
    task currentTask;
    std::string temp; // a temporary variable used to store string data
    while (std::getline(std::cin, temp)) {
        const int taskCount = atoi(temp.c_str()); // read number of tasks
        // parse task priorities
        int* priorities = new int[taskCount];
        for (int i=0; i<taskCount; i++)
            std::cin >> priorities[i];
        // read actual tasks
        for (int i=0; i<taskCount; i++) {
            std::cin >> currentTask.wcet;
            std::cin >> currentTask.deadline;
            std::cin >> currentTask.period;
            currentTask.priority = priorities[i];

            std::cout << "Task " << (i + 1) << ":";
            std::cout << " Priority : " << currentTask.priority;
            std::cout << " WCET : " << currentTask.wcet;
            std::cout << " Deadline : " << currentTask.deadline;
            std::cout << " Period : " << currentTask.period << std::endl;
        }
        delete[] priorities;
    }
    return 0;
}

struct任务{
双wcet；
双重期限；
双周期；
int优先级；
};
int main（int，char**）{
任务当前任务；
std:：string temp；//用于存储字符串数据的临时变量
while（std:：getline（std:：cin，temp））{
const int taskCount=atoi（temp.c_str（））；//读取任务数
//分析任务优先级
int*优先级=新int[taskCount]；
对于（int i=0；i>优先级[i]；
//阅读实际任务
对于（int i=0；i>currentTask.wcet；
std:：cin>>currentTask.deadline；
std:：cin>>currentTask.period；
currentTask.priority=优先级[i]；
标准：：cout