Come posso utilizzare i delimitatori non predefiniti durante la lettura di un file di testo con std :: fstream?

Question

Nel mio codice C++, voglio leggere da un file di testo (* .txt) e tokenize ogni voce. Nello specifico, voglio essere in grado di leggere singole parole da un file, come "format", "stack", "Jason", "europe", ecc..

ho scelto di usare fstream per svolgere questo compito, e non so come impostare è delimitatore a quelle che voglio usare (spazio, \n, così come i trattini e anche apostrofi come in "McDonal di"). Ho immaginato lo spazio e \n sono i delimitatori predefiniti, ma i trattini non lo sono, ma voglio trattarli come delimitatori in modo che quando analizzo il file, otterrò le parole in "blah blah xxx animal - cat" come semplicemente "blah", "blah", "xxx", "animal", "cat".

Cioè, voglio essere in grado di ottenere due stringhe da "stack-overflow", "sei", ecc, ed essere ancora in grado di mantenere \n e lo spazio come delimitatori allo stesso tempo.

Answer 1

un istream ossequi "spazio bianco" come delimitatori. Usa un locale per dirgli quali caratteri sono lo spazio bianco. Una locale, a sua volta, include un tipo di telefono facet che classifica i tipi di carattere. Tale aspetto potrebbe essere simile a questa:

#include <locale> 
#include <iostream> 
#include <algorithm> 
#include <iterator> 
#include <vector> 
#include <sstream> 

class my_ctype : public 
std::ctype<char> 
{ 
    mask my_table[table_size]; 
public: 
    my_ctype(size_t refs = 0) 
     : std::ctype<char>(&my_table[0], false, refs) 
    { 
     std::copy_n(classic_table(), table_size, my_table); 
     my_table['-'] = (mask)space; 
     my_table['\''] = (mask)space; 
    } 
}; 

E un piccolo programma di test per dimostrare che funziona:

int main() { 
    std::istringstream input("This is some input from McDonald's and Burger-King."); 
    std::locale x(std::locale::classic(), new my_ctype); 
    input.imbue(x); 

    std::copy(std::istream_iterator<std::string>(input), 
     std::istream_iterator<std::string>(), 
     std::ostream_iterator<std::string>(std::cout, "\n")); 

    return 0; 
} 

Risultato:

This 
is 
some 
input 
from 
McDonald 
s 
and 
Burger 
King. 

istream_iterator<string> utilizza >> di leggere le singole stringhe dal flusso, quindi se li usi direttamente, dovresti ottenere gli stessi risultati. Le parti che devi includere sono la creazione delle impostazioni internazionali e l'uso di imbue per far sì che lo streaming usi quella locale.

Answer 2

È possibile utilizzare

istream::getline(char* buffer, steamsize maxchars, char delim) 

anche se questa supporta solo un singolo delimitatore. Per dividere ulteriormente le righe sui diversi delimitatori, è possibile utilizzare

char* strtok(char* inString, const char* delims) 

che richiede più delimitatori. Quando usi strtok devi solo passarlo l'indirizzo del tuo buffer la prima volta - dopo di ciò basta passare un null e ti darà il prossimo token dall'ultimo che ti ha dato, restituendo un puntatore nullo quando non ci sono Di Più.

EDIT: un'implementazione specifica sarebbe qualcosa di simile

char buffer[120]; //this size is dependent on what you expect the file to contain 
while (!myIstream.eofbit) //I may have forgotten the exact syntax of the end bit 
{ 
    myIstream.getline(buffer, 120); //using default delimiter of \n 
    char* tokBuffer; 
    tokBuffer = strtok(buffer, "'- "); 
    while (tokBuffer != null) { 
     cout << "token is: " << tokBuffer << "\n"; 
     tokBuffer = strtok(null, "'- "); //I don't need to pass in the buffer again because it remembers the first time I called it 
    } 
}