C++ txt文件解析c++；为了更有效地使用矢量

我的程序使用ifstream（）和getline（）将文本文件解析为两个向量深的对象。i、 向量中的e向量。一旦文本文件加载完毕，内部向量包含250000多个字符串对象

这是令人痛苦的缓慢。是否有比使用ifstream（）和getline（）更有效的STD替代方案

谢谢

更新：

#include <iostream>
#include <fstream>
#include <string>
#include <vector>
#include <regex>

using namespace std;

class Word
{
private:
    string moniker = "";
    vector <string> definition;
    string type = "";

public:
    void setMoniker(string m) { this->moniker = m; }
    void setDefinition(string d) { this->definition.push_back(d); }
    void setType(string t) { this->type = t; }
    int getDefinitionSize() { return this->definition.size(); }

    string getMoniker() { return this->moniker; }
    void printDefinition()
    {
        for (int i = 0; i < definition.size(); i++)
        {
            cout << definition[i] << endl;
        }

    }


    string getType() { return this->type; }
};

class Dictionary
{
private:
    vector<Word> Words;

public:
    void addWord(Word w) { this->Words.push_back(w); }
    Word getWord(int i) { return this->Words[i]; }
    int getTotalNumberOfWords() { return this->Words.size(); }
    void loadDictionary(string f)
    {
        const regex _IS_DEF("[\.]|[\ ]"),
            _IS_TYPE("^misc$|^n$|^adj$|^v$|^adv$|^prep$|^pn$|^n_and_v$"),
            _IS_NEWLINE("\n");

        string line;

        ifstream dict(f);

        string m, t, d = "";

        while (dict.is_open())
        {
            while (getline(dict, line))
            {
                if (regex_search(line, _IS_DEF))
                {
                    d = line;
                }
                else if (regex_search(line, _IS_TYPE))
                {
                    t = line;
                }
                else if (!(line == ""))
                {
                    m = line;
                }
                else
                {
                    Word w;
                    w.setMoniker(m);
                    w.setType(t);
                    w.setDefinition(d);
                    this->addWord(w);
                }
            }
            dict.close();
        }
    }
};



int main()
{
    Dictionary dictionary;
    dictionary.loadDictionary("dictionary.txt");
    return 0;
}

#包括
#包括
#包括
#包括
#包括
使用名称空间std；
类词
{
私人：
字符串名字=”；
矢量定义；
字符串类型=”；
公众：
void setMoniker（字符串m）{this->moniker=m；}
void setDefinition（字符串d）{this->definition.push_back（d）；}
void setType（字符串t）{this->type=t；}
int getDefinitionSize（）{返回此->定义.size（）；}
字符串getMoniker（）{返回此->名字对象；}
void printDefinition（）
{
对于（int i=0；i单词[i]；}
int getTotalNumberOfWord（）{返回此->Words.size（）；}
void loadDictionary（字符串f）
{
常量regex是DEF（“[\.].[\]”），
_是“^misc$^n$^adj$^v$^adv$^prep$^pn$^n$”类型，
_是新线（“\n”）；
弦线；
ifstream dict（f）；
字符串m，t，d=“”；
while（dict.is_open（））
{
while（getline（dict，line））
{
if（regex_搜索（第行，_是_DEF））
{
d=直线；
}
else if（regex_搜索（行，_为_类型））
{
t=直线；
}
如果（！（行==“”），则为else
{
m=直线；
}
其他的
{
单词w；
w、 setMoniker（m）；
w、 集型（t）；
w、 定义（d）；
此->添加单词（w）；
}
}
格言关闭（）；
}
}
};
int main（）
{
字典；
loadDictionary（“dictionary.txt”）；
返回0；
}
您应该减少内存分配。拥有向量向量通常不是一个好主意，因为每个内部向量都有自己的
新建
和
删除

您应该
reserve（）
开始时向量中所需元素的大致数量

如果实际上不需要提取
std:：string
来完成工作，则应使用
fgets（）
。例如，如果可以从
char
数组解析对象，则应这样做。确保每次都读取相同的字符串缓冲区，而不是创建新的缓冲区

最重要的是，使用探查器。
显示代码。250000不够大，速度不够慢，因此一定存在一些更大的问题。看起来是这样的：尝试
常量字符串&
而不是
字符串
。此外，“this->”没有用（它不会使速度变慢，只是没用）。此外，您是否使用所有优化标志进行编译？我真的不明白您在做什么…为什么每个单词都只有一个名字对象、一个类型或一个定义，而不是全部3个？这看起来不是很奇怪吗？而且，与性能更直接相关的是，您的定义没有理由是字符串向量，而不是字符串。a字符串大致上是一个字符向量，因此嵌套的不是2深，而是3深。请澄清代码的作用