Question

我使用以下代码从多个.dat文件中读取并解析它们。此代码使用3D向量在读取过程之后存储数据。但是，我希望与每个文件对应的数据独立于其他文件。问题是文件的数量各不相同，在编译时是未知的;因此，矢量的数量也会变化。我想知道是否有任何解决方案。

vector<vector<vector<string>>> masterList;

for (int i = 0; i < files.size(); ++i) {
    cout << "file name: " << files[i] << endl;

    fin.open(files[i].c_str());
    if (!fin.is_open()) {
        // error occurs!!
        // break or exit according to your needs
        cout<<"error"<<endl;
    }

    std::vector<vector<string>> tokens;

    int current_line = 0;
    std::string line;
    while (std::getline(fin, line))
    {

        cout<<"line number: "<<current_line<<endl;
        // Create an empty vector for this line
        tokens.push_back(vector<string>());

        //copy line into is 
        std::istringstream is(line);
        std::string token;
        int n = 0;

        //parsing
        while (getline(is, token, DELIMITER))
        {
            tokens[current_line].push_back(token);
            cout<<"token["<<current_line<<"]["<<n<<"] = " << token <<endl; 

            n++;
        }
        cout<<"\n";
        current_line++;
    }
    fin.clear();
    fin.close();
    masterList.push_back(tokens);
}

因此，我面临的主要问题是：当我不知道编译时有多少文件时，如何创建可变数量的2D向量来存储与每个文件对应的数据。

Answer 1

修改主文件中的文件列表以调整“主数据”的大小。如果文件名的长度是可变的，则首先解析它（或者首先以某种方式获取它），然后对dat文件执行解析。如果文件名仅在运行时知道，并且与文件名异步，那么每次获得新文件名时都会在列表中添加一个新元素（例如，您可以使用事件来查看https://github.com/Sheljohn/siglot）

请注意，列表元素在内存中是独立的，并列出了在常量时间内删除/插入的内容。这样，对应于每个文件的数据彼此独立。如果要检索特定于文件的数据（知道文件名），请在列表上迭代以查找相应的文件（线性时间）或将列表换成unordered_map（摊销的常量时间）。

#include <string>
#include <list>
#include <vector>
#include <iostream>
#include <sstream>
#include <fstream>
#include <iterator>
#include <algorithm>

using namespace std;

#define AVG_LINES_PER_FILE 100



/**
 * [tokenize_string Tokenize input string 'words' and put elements in vector 'tokens'.]
 * @param words  [Space separated data-string.]
 * @param tokens [Vector of strings.]
 */
void tokenize_string( string& words, vector<string>& tokens )
{
    unsigned n = count( words.begin(), words.end(), ' ' );
    tokens.reserve(n);

    istringstream iss(words);
    copy( 
        istream_iterator<string>(iss), 
        istream_iterator<string>(), 
        back_inserter<vector<string> >(tokens) 
    );
}



/**
 * Contains data parsed from a single .dat file
 */
class DATFileData
{
public:

    typedef vector<string> line_type;
    typedef vector<line_type> data_type;

    DATFileData( const char* fname = nullptr )
        {
            m_fdata.reserve(AVG_LINES_PER_FILE);
            m_fdata.clear();

            if ( fname ) parse_file(fname);
        }

    // Check if the object contains data
    inline operator bool() const { return m_fdata.size(); }

    // Parse file
    bool parse_file( const char* fname )
        {
            string line;
            m_fdata.clear();
            ifstream fin( fname );

            if ( fin.is_open() )
            {
                while ( fin.good() )
                {
                    getline(fin,line);
                    m_fdata.push_back(line_type());
                    tokenize_string( line, m_fdata.back() );
                }
                fin.close();

                m_fname = fname;
                cout << "Parsed " << m_fdata.size() << " lines in file '" << fname << "'." << endl;
                return true;

            }
            else 
            {
                cerr << "Could not parse file '" << fname << "'!" << endl;
                return false;
            }
        }

    // Get data
    inline unsigned size() const { return m_fdata.size(); }
    inline const char* filename() const { return m_fname.empty() ? nullptr : m_fname.c_str(); }
    inline const data_type& data() const { return m_fdata; }
    inline const line_type& line( const unsigned& i ) const { return m_fdata.at(i); }

private:

    string m_fname;
    data_type m_fdata;
};



int main()
{

    unsigned fcount = 0;
    vector<string> files = {"some/file/path.dat","another/one.dat"};
    list<DATFileData> data(files.size());

    for ( DATFileData& d: data ) 
        d.parse_file( files[fcount++].c_str() );

    cout << endl << files.size() << " files parsed successfully." << endl;
}

存储来自未知数量文件的数据

1 个答案: