Insérer dynamiquement des chaînes dans un fichier std :: map

Question

J'essaie de créer une carte de paires de fichiers ... Tout d'abord, je recherche un répertoire spécifié pour les fichiers utilisant FindFirstFile et FindNextFile et quand un fichier est trouvé, je recherche la carte pour voir si le fichier associé est là. Si l'autre fichier a été ajouté à la carte, le nouveau fichier trouvé est inséré à côté de celui précédemment trouvé. Si un fichier associé n'a pas été trouvé, le nouveau fichier est inséré dans la carte et sa paire est laissée intacte.

Pour expliquer plus: permet de dire que nous avons 2 fichiers file.1.a et fichier.1 ces fichiers représentent une paire et doivent donc être ajoutées à la carte comme une paire

//map<File w/o .a, File w .a> 
std::map<CString, CString> g_map; 

int EnumerateFiles(LPCTSTR Dir) 
{ 
    //Search Files.... 
    //Found a File....(for ex: file.1) 
    //Append .a to the string and search for it in the map 
    BOOL bAdded = FALSE; 
    for(std::map<CString, CString>::iterator itr = g_map.begin(); itr != g_map.end(); itr++) 
     { 
     if(StrCmp(tchAssocFile, itr->second) == 0) 
     { 
       bAdded = TRUE; 
       //pair the string with the other one; 
     } 

     } 
    if(!bAdded) 
     //Add the new string to the map and leave its associate blank 


    //Do the same in reverse if the associate was found first.... 
} 

J'espère c'était clair comme je ne peux pas penser à une autre façon de le dire ... sry.

Pouvez-vous s'il vous plaît aider à résoudre ce problème ...

ce qui a trait

Answer 1

Vous avez deux fichiers.
{X} et {X} .a

Vous souhaitez rechercher un espace de répertoire et stocker ceux que vous trouvez.

Consignons les informations d'une trouvaille dans une paire std :: < bool, bool >.
La première valeur représente si nous trouvons {x} la deuxième valeur représente si nous trouvons {X} .a
Ces valeurs de paires sont stockées dans une carte en utilisant {X} comme index dans la carte.

#include <memory> 
#include <string> 
#include <map> 

typedef std::pair<bool,bool>   FileInfo; 
typedef std::map<std::string,FileInfo> FileMapInfo; 



FileMapInfo  fileMapInfo; 

void found(std::string const& fileName) 
{ 
    // baseName: We will use this to lookup if either file is found. 
    //    The extension ".a" is removed from this name. 
    // aExtension: is true if the file ends with ".a" 
    std::string baseName(fileName); 
    bool  aExtension(false); 

    std::string::size_type pos = fileName.find_last_of(".a"); 
    if ((pos != std::string::npos) && (pos == fileName.size()-2)) 
    { 
     // Get the real base 
     baseName = fileName.substr(0,fileName.size() - 2); 
     aExtension = true; 
    } 


    // This looks up the record about the file(s). 
    // If it dies not exist it creates an entry with false,false. 
    FileInfo& fileInfo = fileMapInfo[baseName]; 

    // Now set the appropriate value to true. 
    if (!aExtension) 
    { 
     fileInfo.first  = true; 
    } 
    else 
    { 
     fileInfo.second  = true; 
    } 
} 

int main() 
{ 
    // loop over files. 
    // call found(<fileName>); 
} 

Answer 2

Si l'efficacité est un problème, vous auriez soit maintenir deux cartes (pour les deux directions de requêtes, ou utilisez un bi Mais en regardant votre problème, je pense que deux ensembles (std :: set) pourraient mieux fonctionner: dans l'un, vous placez les fichiers .a dans l'autre. fichiers, et à la fin, vous prenez l'intersection std :: :) :).

Answer 3

Je pense que je ferais quelque chose comme ceci:

string tchFile = <name of file you just found>; 
string tchAssocFile = <name of associated file if it exists, empty otherwise>; 

if (tchAssocFile.empty()) 
    g_map[tchFile] = ""; 
else { 
    std::map<string, string>::iterator foundAssocIter = g_map.find(tchAssocFile); 
    if (foundAssocIter != g_map.end()) 
     foundAssocIter->second = tchFile; 
    else 
     g_map[tchFile] = tchAssocFile; 
}