C ++ Lecture de jetons de fichier

Question

une autre demande désolé .. En ce moment, je lis les jetons un par un et ça marche, mais je veux savoir quand il y a une nouvelle ligne.

si mon fichier contient

Hey Bob
Now

devrait me donner

Hey
Bob
[NEW LINE]
NOW

Y a-t-il un moyen de faire cela sans utiliser getline?

Answer 1

Oui, l'opérateur > > lorsqu'il est utilisé avec une chaîne, lisez les mots séparés par un "espace blanc". Un "espace blanc" comprend un espace et des caractères de nouvelle ligne.

Si vous voulez lire une ligne à la fois, utilisez std :: getline ()
La ligne peut ensuite être segmentée séparément avec un flux de chaîne.

std::string   line;
while(std::getline(std::cin,line))
{

    // If you then want to tokenize the line use a string stream:

    std::stringstream lineStream(line);
    std::string token;
    while(lineStream >> token)
    {
        std::cout << "Token(" << token << ")\n";
    }

    std::cout << "New Line Detected\n";
}

Petit ajout:

Sans utiliser getline ()

Donc, vous voulez vraiment pouvoir détecter une nouvelle ligne. Cela signifie que la nouvelle ligne devient un autre type de jeton. Supposons donc que vous avez des mots séparés par des "espaces" en tant que jetons et un nouveau trait en tant que son propre jeton.

Vous pouvez ensuite créer un type de jeton.
Il ne reste plus qu’à écrire les opérateurs de flux pour un jeton:

#include <iostream>
#include <fstream>

class Token
{
    private:
        friend std::ostream& operator<<(std::ostream&,Token const&);
        friend std::istream& operator>>(std::istream&,Token&);
        std::string     value;
};
std::istream& operator>>(std::istream& str,Token& data)
{
    // Check to make sure the stream is OK.
    if (!str)
    {   return str;
    }

    char    x;
    // Drop leading space
    do
    {
        x = str.get();
    }
    while(str && isspace(x) && (x != '\n'));

    // If the stream is done. exit now.
    if (!str)
    {
        return str;
    }

    // We have skipped all white space up to the
    // start of the first token. We can now modify data.
    data.value  ="";

    // If the token is a '\n' We are finished.
    if (x == '\n')
    {   data.value  = "\n";
        return str;
    }

    // Otherwise read the next token in.
    str.unget();
    str >> data.value;

    return str;
}
std::ostream& operator<<(std::ostream& str,Token const& data)
{
    return str << data.value;
}


int main()
{
    std::ifstream   f("PLOP");
    Token   x;

    while(f >> x)
    {
        std::cout << "Token(" << x << ")\n";
    }
}

Answer 2

Je ne sais pas pourquoi vous pensez que std :: getline est mauvais. Vous pouvez toujours reconnaître les nouvelles lignes.

std::string token;
std::ifstream file("file.txt");
while(std::getline(file, token)) {
    std::istringstream line(token);
    while(line >> token) {
        std::cout << "Token :" << token << std::endl;
    }
    if(file.unget().get() == '\n') {
        std::cout << "newline found" << std::endl;
    }
}

Answer 3

C’est une autre façon cool et beaucoup moins verbeuse que j’ai rencontré de créer des chaînes symboliques.

vector<string> vec; //we'll put all of the tokens in here 
string token;
istringstream iss("put text here"); 

while ( getline(iss, token, '\n') ) {
       vec.push_back(token);
}