Jedes einzelne Wort aus einer Zeichenfolge in C++ nehmen

Question

Ich schreibe eine Methode in C++, die eine Zeichenfolge aus 2 oder mehr Wörtern und geben Sie jedes einzelne Wort der Zeichenfolge getrennt durch eine Sekunde oder so mit der sleep() Methode. Ich versuche dies mit einer for-Schleife und Substrings zu tun. Ich bin mir auch nicht sicher, welche Regexs verwendet werden sollten und wie sie verwendet werden sollten, um die gewünschte Ausgabe zu erzielen.

Ich habe this und this überprüft und finde meine Frage unterscheidet, da ich versuche, dies in einer Schleife zu tun, und nicht die einzelnen Teilstrings speichern.

Input:

"Dies ist ein Beispiel"

gewünschte Ausgabe:

"This" (Pause), "ist" (Pause), "an" (Pause) " Beispiel."

Answer 1

Verwenden std::stringstream, keine reguläre Ausdrücke erforderlich:

#include <iostream> 
#include <sstream> 
using namespace std; 

int main() { 
    stringstream ss("This is a test"); 
    string s; 

    while (ss >> s) { 
     cout << s << endl; 
    } 

    return 0; 
} 

Auch sehen How do I tokenize a string in C++?

Answer 2

Sie können Ihre eigene Methode implementieren:

//StrParse.h 

    #pragma once 

    #include <iostream> 

    static counter = 0; 

    char* strPar(char* pTxt, char c) 
    { 

     int lenAll = strlen(pTxt); 

     bool strBeg = false; 
     int nWords = 0; 


     for(int i(0); i < lenAll; i++) 
     { 
      while(pTxt[i] != c) 
      { 
       strBeg = true; 
       i++; 
      } 
      if(strBeg) 
      { 
       nWords++; 
       strBeg = false; 
      } 

     } 

     int* pLens = new int[nWords]; 
     int j = 0; 
     int len = 0; 

     for(i = 0; i < lenAll; i++) 
     { 
      while(pTxt[i] != c) 
      { 
       strBeg = true; 
       i++; 
       len++; 
      } 
      if(strBeg) 
      { 
       pLens[j] = len; 
       j++; 
       strBeg = false; 
       len = 0; 
      } 

     } 

     char** pStr = new char*[nWords + 1]; 

     for(i = 0; i < nWords; i++) 
      pStr[i] = new char[pLens[i] + 1]; 

     int k = 0, l = 0; 

     for(i = 0; i < lenAll; i++) 
     { 
      while(pTxt[i] != c) 
      { 
       strBeg = true; 
       pStr[k][l] = pTxt[i]; 
       l++; 
       i++; 
      } 
      if(strBeg) 
      { 
       pStr[k][l] = '\0'; 
       k++; 
       l = 0; 
       strBeg = false;  
      } 

     } 

     counter++; 

     if(counter <= nWords) 
      return pStr[counter - 1]; 
     else 
      return NULL; 
    } 


    //main.cpp 


    #include "StrParse.h" 

    void main() 
    { 

     char* pTxt = " -CPlusPlus -programming -is -a - superb thing "; 
     char* pStr1 = NULL; 
     int i = 1; 
     char sep; 

     std::cout << "Separator: "; 
     sep = std::cin.get(); 
     std::cin.sync(); 

     while(pStr1 = strPar(pTxt, sep)) 
     { 
      std::cout << "String " << i << ": " << pStr1 << std::endl; 
      delete pStr1; 
      i++; 
     } 

     std::cout << std::endl; 
    } 

Answer 3

Hier ein Paar Implementierungen, die don sind‘ Es müssen keine externen Puffer erstellt werden.

#include <boost/range/adaptor/filtered.hpp> 
#include <boost/range/algorithm/copy.hpp> //for boost::copy 

#include <chrono> 
#include <iostream> 
#include <string> 
#include <experimental/string_view> //in clang or gcc; or use boost::string_ref in boost 1.53 or later; or use boost::iterator_range<char*> in earlier version of boost 
#include <thread> 

void method_one(std::experimental::string_view sv) 
{ 
    for(auto b = sv.begin(), e = sv.end(), space = std::find(b, e, ' ') 
     ; b < e 
     ; b = space + 1, space = std::find(space + 1, e, ' ')) 
    { 
     std::copy(b, space, std::ostreambuf_iterator<char>(std::cout)); 
     std::cout << " (pause) "; //note that this will spit out an extra pause the last time through 
     std::this_thread::sleep_for(std::chrono::seconds(1)); 
    } 
} 

void method_two(std::experimental::string_view sv) 
{ 
    boost::copy(
     sv | boost::adaptors::filtered([](const char c) -> bool 
     { 
      if(c == ' ') 
      { 
       std::cout << " (pause) "; //note that this spits out exactly one pause per space character 
       std::this_thread::sleep_for(std::chrono::seconds(1)); 
       return false; 
      } 

      return true; 
     }) 
     , std::ostreambuf_iterator<char>(std::cout) 
    ); 
} 

int main() { 
    const std::string s{"This is a string"}; 

    method_one(s); 
    std::cout << std::endl; 
    method_two(s); 
    std::cout << std::endl; 

    return 0; 
} 

Live on coliru, wenn Sie daran interessiert sind.