¿Existe una forma integrada de dividir cadenas en C++?

Question

¿está bien? por la cadena me refiero a std :: string

Answer 1

cadenas de C

Basta con insertar una \0 donde desea dividir. Esto es lo más integrado que se puede obtener con las funciones C estándar.

Esta función se divide en la primera aparición de un separador char, devolviendo la segunda cadena.

char *split_string(char *str, char separator) { 
    char *second = strchr(str, separator); 
    if(second == NULL) 
     return NULL; 

    *second = '\0'; 
    ++second; 
    return second; 
} 

Answer 2

La respuesta es no. Tienes que dividirlos usando una de las funciones de la biblioteca.

algo que utilizo:

std::vector<std::string> parse(std::string l, char delim) 
{ 
    std::replace(l.begin(), l.end(), delim, ' '); 
    std::istringstream stm(l); 
    std::vector<std::string> tokens; 
    for (;;) { 
     std::string word; 
     if (!(stm >> word)) break; 
     tokens.push_back(word); 
    } 
    return tokens; 
} 

También puede echar un vistazo al método basic_streambuf<T>::underflow() y escribir un filtro.

Answer 3

cadenas STL

Puede usar iteradores de cadena para hacer su trabajo sucio.

std::string str = "hello world"; 

std::string::const_iterator pos = std::find(string.begin(), string.end(), ' '); // Split at ' '. 

std::string left(str.begin(), pos); 
std::string right(pos + 1, str.end()); 

// Echoes "hello|world". 
std::cout << left << "|" << right << std::endl; 

Answer 4

void split(string StringToSplit, string Separators) 
{ 
    size_t EndPart1 = StringToSplit.find_first_of(Separators) 
    string Part1 = StringToSplit.substr(0, EndPart1); 
    string Part2 = StringToSplit.substr(EndPart1 + 1); 
} 

Answer 5

No hay manera integrada para dividir una cadena en C++, pero boost proporciona la biblioteca string algo para hacer todo tipo de manipulación de cadenas, incluyendo cadena splitting.

Answer 6

Aquí hay una función de división de estilo Perl que utilizo:

void split(const string& str, const string& delimiters , vector<string>& tokens) 
{ 
    // Skip delimiters at beginning. 
    string::size_type lastPos = str.find_first_not_of(delimiters, 0); 
    // Find first "non-delimiter". 
    string::size_type pos  = str.find_first_of(delimiters, lastPos); 

    while (string::npos != pos || string::npos != lastPos) 
    { 
     // Found a token, add it to the vector. 
     tokens.push_back(str.substr(lastPos, pos - lastPos)); 
     // Skip delimiters. Note the "not_of" 
     lastPos = str.find_first_not_of(delimiters, pos); 
     // Find next "non-delimiter" 
     pos = str.find_first_of(delimiters, lastPos); 
    } 
} 

Answer 7

¿Qué diablos ... Aquí está mi versión ...

Nota: que parte en ("XZaaaXZ", "XZ") te dará 3 cuerdas 2 de esas cadenas estarán vacías, y no se agregará a en el StringVector si el IncludeEmptyStrings es falso.

Delimitador es no cualquier elemento en el conjunto, sino que coincide con esa cadena exacta.

inline void 
StringSplit(vector<string> * theStringVector, /* Altered/returned value */ 
      const string & theString, 
      const string & theDelimiter, 
      bool    theIncludeEmptyStrings = false) 
{ 
    UASSERT(theStringVector, !=, (vector<string> *) NULL); 
    UASSERT(theDelimiter.size(), >, 0); 

    size_t start = 0, end = 0, length = 0; 

    while (end != string::npos) 
    { 
    end = theString.find(theDelimiter, start); 

     // If at end, use length=maxLength. Else use length=end-start. 
    length = (end == string::npos) ? string::npos : end - start; 

    if ( theIncludeEmptyStrings 
     || ( (length > 0) /* At end, end == length == string::npos */ 
      && (start < theString.size()))) 
     theStringVector -> push_back(theString.substr(start, length)); 

     // If at end, use start=maxSize. Else use start=end+delimiter. 
    start = ( (end > (string::npos - theDelimiter.size())) 
       ? string::npos : end + theDelimiter.size() ); 
    } 
} 


inline vector<string> 
StringSplit(const string & theString, 
      const string & theDelimiter, 
      bool    theIncludeEmptyStrings = false) 
{ 
    vector<string> v; 
    StringSplit(& v, theString, theDelimiter, theIncludeEmptyStrings); 
    return v; 
} 

Answer 8

Un método bastante sencillo sería utilizar el método c_str() de std :: string para obtener una matriz de caracteres de estilo C, a continuación, utilizar strtok() para tokenize la cadena. No es tan elocuente como algunas de las otras soluciones enumeradas aquí, pero es fácil y funciona.

Answer 9

Yup, stringstream.

std::istringstream oss(std::string("This is a test string")); 
std::string word; 
while(oss >> word) { 
    std::cout << "[" << word << "] "; 
} 

Answer 10

No hay una forma común de hacerlo.

Prefiero el boost::tokenizer, solo su encabezado y fácil de usar.