C++ - String-Management konvertieren rohe Zeichenfolge durch Wörterbuch-Matching

Question

Was dieser Code ist, dass eine Zeichenfolge gegeben, wird es durch das Array an der Unterseite, so dass wenn eine Zeichenfolge eines der Array-Element übereinstimmt, alle neuen Bits einer Zeichenfolge wird zu einem neuen String zusammengefügt und dann wieder zurückgegeben! Mit anderen Worten, es wandelt eine lange und rohe Zeichenkette um, indem es im "Wörterbuch" nachschlägt und dann die interpretierte neue Zeichenkette zurückgibt.

Ich versuche, etwas Code bei // Kommentar hinzuzufügen, so dass, wenn ich rohe Zeichenfolgen, die nichts übereinstimmen, wie im Array trifft, wird es eine andere Funktion aufrufen, um damit umzugehen. Ich denke darüber nach, es zu protokollieren, damit ich das Wörterbuch aktualisieren kann.

danke!

string string_look_up(string data) 
{ 
string loc_string = ""; 

std::stringstream ss(data); 

std::string line; 
while (std::getline(ss, line, '0')) 
{ 
    if (line.empty()) 
    { 
     continue; 
    } 

    cout << line << endl; 
    for (int i = 0; i < 82; i++) 
    { 
     if (line == dictionary_array_strings_raw[i]) 
     { 
      loc_string = loc_string + dictionary_array_strings_digits[i]; 
     } 

    } 

    /// this is where the new code I want should be 

    cout << loc_string << endl; 
    cout << "######" << endl; 
} 

return loc_string; 
} 

const string dictionary_array_strings_raw[] = { // x 
               "25643663", 
               // Y 
               "2346442", "2446442", 
               // Z 
               "3676764", 
               // : 
               "4", 
               // - 
               "111" } 

const string dictionary_array_strings_digits[] = { // x 
                "X", 
                // Y 
                "Y", "Y", 
                // Z 
                "Z", 
                // : 
                ":", 
                // - 
                "-", 
                // 1 } 

Answer 1

Sie können std::find verwenden, um die rohe Zeichenfolge innerhalb des Arrays zu suchen. Um den Index für das Ziffern-Array zu erhalten, subtrahieren Sie einfach den Anfang des Arrays vom Iterator, der von std :: find zurückgegeben wurde.

std :: find benötigt zwei Iteratoren (Anfang und Ende) für den Suchbereich. Einfache Zeiger können als Iteratoren verwendet werden (weil sie Inkrementieren (++) und Dereferenzieren (*) unterstützen). Der Rückgabewert ist entweder ein Interator, der auf das erste gefundene Element zeigt, oder ein End-Iterator, der auf das Ende (eins nach dem letzten Element) zeigt.

Mit dem Parameter std :: function können Sie einen Rückruf für Zeilen angeben, die im Raw-String-Array nicht gefunden werden. Sie können eine beliebige Funktion oder ein Lambda verwenden, das der Signatur entspricht (const std::string& Parameter und std::string Rückgabewert).

WARNUNG: Der folgende Code ist nicht korrekt. Es verwendet 82 für die Anzahl der Wörterbucheinträge (wie der Code aus dem ursprünglichen Post), aber es definiert nur 6 Wörterbucheinträge. Dies führt zu einem nicht definierten Verhalten, wenn unbekannte rohe Strings verwendet werden. Sie sollten 76 Wörterbucheinträge hinzufügen oder die Eingabe-Zahl von 82 bis 6.

#include <string> 
#include <map> 
#include <sstream> 
#include <algorithm> 
#include <functional> 
#include <iostream> 
#include <cassert> 

using namespace std; 

const string dictionary_array_strings_raw[] = { // x 
    "25643663", 
    // Y 
    "2346442", "2446442", 
    // Z 
    "3676764", 
    // : 
    "4", 
    // - 
    "111" 
}; 

const string dictionary_array_strings_digits[] = { // x 
    "X", 
    // Y 
    "Y", "Y", 
    // Z 
    "Z", 
    // : 
    ":", 
    // - 
    "-", 
    // 1 
}; 

string string_look_up(string data, std::function<std::string(const std::string&)> callback) 
{ 
    assert(callback != nullptr); 

    const auto dictionary_array_strings_raw_end = dictionary_array_strings_raw + 82; 

    std::string loc_string = ""; 

    std::stringstream ss(data); 

    std::string line; 
    while (std::getline(ss, line, '0')) 
    { 
     if (line.empty()) 
     { 
      continue; 
     } 

     cout << line << endl; 
     const auto it = std::find(dictionary_array_strings_raw, dictionary_array_strings_raw_end, line); 

     if (it == dictionary_array_strings_raw_end) 
      loc_string += callback(line); 
     else 
      loc_string += dictionary_array_strings_digits[it - dictionary_array_strings_raw]; 

     cout << loc_string << endl; 
     cout << "######" << endl; 
    } 

    return loc_string; 
} 

Das folgende Beispiel zeigt die Verwendung eines Lambda für unbekannte rohe Strings (‚99‘ im Beispiel) reduzieren.

int main(int argc, char **argv) 
{ 
    const auto result = string_look_up("25643663023464420990", [](const std::string& line) { return '<' + line + '>'; }); 
    std::cout << "Result:\n" << result; 

    return 0; 
} 

Wenn string_look_up auf die Zeile mit dem Wert 99 trifft, wird versucht, eine passende Raw-Zeichenfolge zu finden. Wenn es keine passende rohe Zeichenkette findet, ruft es die Callback-Funktion mit "99" als einzigem Parameter auf. Das in main definierte Lambda fügt "<" vor und ">" nach dem Zeilenwert hinzu und gibt das Ergebnis an string_look_up() zurück, das den Rückgabewert zum Ergebnis hinzufügt.

Der Eingang 25643663023464420990 Ergebnisse in der Ausgabe XY<99> (und eine Menge Debug-Ausgabe)

Ich würde empfehlen, ein std :: map für die Übersetzungstabelle (raw Strings als Schlüssel, Ziffern als Werte) verwenden. Mit einer Map können Sie die find() -Memberfunktion verwenden, um den Iterator zu erhalten (nennen wir es 'it'), und it-> second, um die Ziffernfolge zu erhalten.Hier

ist ein Beispiel für die statische Initialisierung einer Karte:

const std::map<std::string, std::string> translationTable = { 
    {"25643663", "X"}, 
    {"2346442", "Y"}, 
    {"2446442", "Y" } 
    // ... 
}; 

Sie können für einen Wert mit const auto it = translationTable.find(line); suchen und vergleichen Sie es mit translationTable.end() zu überprüfen, ob die Suche erfolgreich war. it->first enthält die rohe Zeichenfolge (d. H. "25643663"), während it->second die Ziffernfolge enthält (d. H. "X")

Answer 2

Haben Sie eine bool Flagge für die Schleife. Wenn Sie eine Übereinstimmung finden, setzen Sie sie auf wahr. Dann können Sie überprüfen, wo sich Ihr Kommentar befindet.

if(flag) 
{ 
//code if found 
} 
else 
{ 
//code if not found 
}