Was ist ein richtiger Weg, um in eine Karte der Liste der Liste einfügen

Question

Ich erstelle eine Indexer-Anwendung in C++. Jedes einzelne Wort in den Textdateien eines Verzeichnisses, mag ich wie- first_map < „Wort“ speichern, second_map < „File Objektverweis“, List {Zeilennummern}>

diese Karte erstes Mal füllen, Ich analysiere jede Datei Wort für Wort im Verzeichnis. Um die Daten in der Karte zu drücken, ich einen Kompilierungsfehler bekommen, während Sie wie-

pool[token][it].push_back(count); 

Ich denke, das nicht einen Fehler werfen würde, wenn innere Karte Wert vom Typ int ist. Ich versuche auch, wie-

pool[token].insert(std::make_pair(it, count); 

Dies ist auch fehlgeschlagen mit einem Fehler zu verwenden. Was ist der richtige Weg, um Daten in diesen Container einzufügen?

komplette Quelle unten-

gegeben

#include <sys/types.h> 
#include <sys/stat.h> 
#include <unistd.h> 
#include <stdlib.h> 
#include <dirent.h> 
#include <errno.h> 
#include <string.h> 
#include<iostream> 
#include<iterator> 
#include<algorithm> 
#include<string> 
#include<sstream> 
#include<list> 
#include<vector> 
#include<fstream> 
#include<map> 
#include<ctime> 

class File { 
    public: 
    std::string file_name; 
    int timestamp; 
    File(std::string name) : file_name(name) { 
     struct stat st; 
     int ierr = stat (file_name.c_str(), &st); 
     if (ierr != 0) { 
     std::cout << "error in getting timestamp"; 
     } 
     timestamp = st.st_mtime; 
    } 
}; 

class Location { 
    public: 
    std::vector<File> indexer; 
    virtual std::map<File*, std::list<int> > find_pattern(std::string& word); 
    Location(const char* in_dir){ 
     DIR* FD; 
     struct dirent* in_file; 
     /* Scanning the in directory */ 
     if (NULL == (FD = opendir (in_dir))) 
     { 
     fprintf(stderr, "Error : Failed to open input directory - %s\n", strerror(errno)); 
     throw -1; 
     } 
     while ((in_file = readdir(FD))) 
     { 
     if (!strcmp (in_file->d_name, ".")) 
      continue; 
     if (!strcmp (in_file->d_name, "..")) 
      continue; 
     indexer.push_back(File(in_file->d_name)); 

     } 
    } 
}; 
class TextFileLocation : public Location { 
    public: 
    std::map<std::string, std::map<File*, std::list<int> > > pool; 
    TextFileLocation(const char* in_dir) : Location(in_dir){ 

     for(auto it = indexer.begin(); it != indexer.end(); it++){ 
     std::ifstream file1(it->file_name); 
     if(!file1) 
     { 
      std::cout<<"Error opening output file"<<std::endl; 
      continue; 
     } 
     std::string line; 
     std::string token; 
     int count = 0; 
     while (std::getline(file1, line)) 
     { 
      count++; 
      std::map<File*, std::list<int> > *file_line = 
      std::istringstream ss(line); 
      while(std::getline(ss, token, ' ')) { 
       if(token.empty()) 
       continue; 
       pool[token][it].push_back(count); 
      } 
     } 
     } 
    } 
    std::map<File*, std::list<int> > find_pattern(std::string& word){ 
     return pool[word]; 
    } 
}; 

Answer 1

Die gute Nachricht:

an den Compiler gehen weg in Frage auf der Linie zu machen:

pool[token][&*it].push_back(count); 

it ist ein std::vector<File>::iterator und pool ist ein

std::map<std::string, std::map<File*, std::list<int> > > 

Also, um eine einfache File * von einem Iterator zu bekommen, ist "& *" der typische Ansatz.

Die schlechte Nachricht:

Das wird nicht funktionieren. Sobald std::vector<File> neu zugeordnet wird, werden alle nativen Zeiger und Iteratoren für den Inhalt ungültig. Ihre std::map wird mit Zeigern auf nie-nie-Land verlassen werden.

Und wenn das Objekt, von dem diese Struktur ist, kopiert oder verschoben wird, wird auch alles aus dem hohen Orbit abgebrannt.

Sie müssen das Gesamtdesign Ihrer Daten und Container komplett überdenken.