Comment puis-je parcourir les mots d'une chaîne?
https://stackoverflow.com/questions/236129
italiano
english
français
española
中国
日本の
العربية
Deutsch
한국어
Português
RussianQuestion
J'essaie de parcourir les mots d'une chaîne.
On peut supposer que la chaîne est composée de mots séparés par des espaces.
Notez que je ne suis pas intéressé par les fonctions de chaîne C ni par ce type de manipulation / d’accès aux caractères. De plus, donnez la priorité à l'élégance plutôt qu'à l'efficacité.
La meilleure solution que j'ai actuellement est la suivante:
#include <iostream>
#include <sstream>
#include <string>
using namespace std;
int main()
{
string s = "Somewhere down the road";
istringstream iss(s);
do
{
string subs;
iss >> subs;
cout << "Substring: " << subs << endl;
} while (iss);
}
Existe-t-il un moyen plus élégant de le faire?
La solution
Pour ce qui en vaut la peine, voici un autre moyen d'extraire des jetons d'une chaîne d'entrée en utilisant uniquement les fonctions de bibliothèque standard. C’est un exemple de la puissance et de l’élégance du design de la STL.
#include <iostream>
#include <string>
#include <sstream>
#include <algorithm>
#include <iterator>
int main() {
using namespace std;
string sentence = "And I feel fine...";
istringstream iss(sentence);
copy(istream_iterator<string>(iss),
istream_iterator<string>(),
ostream_iterator<string>(cout, "\n"));
}
Au lieu de copier les jetons extraits dans un flux de sortie, vous pouvez les insérer dans un conteneur en utilisant le même algorithme générique copy.
vector<string> tokens;
copy(istream_iterator<string>(iss),
istream_iterator<string>(),
back_inserter(tokens));
... ou créez le vector directement:
vector<string> tokens{istream_iterator<string>{iss},
istream_iterator<string>{}};
Autres conseils
J'utilise ceci pour scinder une chaîne de caractères par un délimiteur. Le premier place les résultats dans un vecteur pré-construit, le second renvoie un nouveau vecteur.
#include <string>
#include <sstream>
#include <vector>
#include <iterator>
template<typename Out>
void split(const std::string &s, char delim, Out result) {
std::stringstream ss(s);
std::string item;
while (std::getline(ss, item, delim)) {
*(result++) = item;
}
}
std::vector<std::string> split(const std::string &s, char delim) {
std::vector<std::string> elems;
split(s, delim, std::back_inserter(elems));
return elems;
}
Notez que cette solution n'ignore pas les jetons vides. Par conséquent, les éléments suivants trouveront 4 éléments, dont l'un est vide:
std::vector<std::string> x = split("one:two::three", ':');
Une solution possible avec Boost pourrait être:
#include <boost/algorithm/string.hpp>
std::vector<std::string> strs;
boost::split(strs, "string to split", boost::is_any_of("\t "));
Cette approche est peut-être même plus rapide que la stringstream. Et puisqu'il s'agit d'une fonction de modèle générique, il peut être utilisé pour scinder d'autres types de chaînes (wchar, etc. ou UTF-8) en utilisant toutes sortes de délimiteurs.
Consultez la documentation pour plus de détails.
#include <vector>
#include <string>
#include <sstream>
int main()
{
std::string str("Split me by whitespaces");
std::string buf; // Have a buffer string
std::stringstream ss(str); // Insert the string into a stream
std::vector<std::string> tokens; // Create vector to hold our words
while (ss >> buf)
tokens.push_back(buf);
return 0;
}
Pour ceux avec qui il n’est pas bon de s'asseoir, sacrifiez toute efficacité pour la taille du code et voyez & "efficient &"; En tant que type d’élégance, les éléments suivants devraient trouver leur bonheur (et je pense que la classe des conteneurs de modèles est un ajout extrêmement élégant.):
template < class ContainerT >
void tokenize(const std::string& str, ContainerT& tokens,
const std::string& delimiters = " ", bool trimEmpty = false)
{
std::string::size_type pos, lastPos = 0, length = str.length();
using value_type = typename ContainerT::value_type;
using size_type = typename ContainerT::size_type;
while(lastPos < length + 1)
{
pos = str.find_first_of(delimiters, lastPos);
if(pos == std::string::npos)
{
pos = length;
}
if(pos != lastPos || !trimEmpty)
tokens.push_back(value_type(str.data()+lastPos,
(size_type)pos-lastPos ));
lastPos = pos + 1;
}
}
Je choisis généralement d'utiliser std::vector<std::string> les types comme deuxième paramètre (ContainerT) ... mais list<> est bien plus rapide que vector<> lorsque l'accès direct n'est pas nécessaire et que vous pouvez même créer votre propre chaîne de caractères et utilisez quelque chose comme std::list<subString> où subString ne fait aucune copie pour des augmentations de vitesse incroyables.
C'est plus du double de la tokenize la plus rapide sur cette page et presque 5 fois plus rapide que certaines autres. De plus, avec les types de paramètres parfaits, vous pouvez éliminer toutes les copies de chaînes et de listes pour des gains de vitesse supplémentaires.
De plus, il ne fait pas le retour du résultat (extrêmement inefficace), mais passe plutôt les jetons comme référence, vous permettant ainsi de construire des jetons en utilisant plusieurs appels si vous le souhaitez.
Enfin, il vous permet de spécifier si vous souhaitez supprimer les jetons vides des résultats via un dernier paramètre facultatif.
Tout ce dont il a besoin, c'est std::string ... le reste est optionnel. Il n’utilise pas de flux ni la bibliothèque boost, mais il est suffisamment flexible pour accepter naturellement certains de ces types étrangers.
Voici une autre solution. C'est compact et raisonnablement efficace:
std::vector<std::string> split(const std::string &text, char sep) {
std::vector<std::string> tokens;
std::size_t start = 0, end = 0;
while ((end = text.find(sep, start)) != std::string::npos) {
tokens.push_back(text.substr(start, end - start));
start = end + 1;
}
tokens.push_back(text.substr(start));
return tokens;
}
Il peut facilement être modélisé pour gérer les séparateurs de chaînes, les chaînes larges, etc.
Notez que la division "" donne une seule chaîne vide et que la division "," (c.-à-d. sep) donne deux chaînes vides.
Il peut également être facilement étendu pour ignorer les jetons vides:
std::vector<std::string> split(const std::string &text, char sep) {
std::vector<std::string> tokens;
std::size_t start = 0, end = 0;
while ((end = text.find(sep, start)) != std::string::npos) {
if (end != start) {
tokens.push_back(text.substr(start, end - start));
}
start = end + 1;
}
if (end != start) {
tokens.push_back(text.substr(start));
}
return tokens;
}
Si vous souhaitez fractionner une chaîne sur plusieurs délimiteurs tout en ignorant les jetons vides, vous pouvez utiliser cette version:
std::vector<std::string> split(const std::string& text, const std::string& delims)
{
std::vector<std::string> tokens;
std::size_t start = text.find_first_not_of(delims), end = 0;
while((end = text.find_first_of(delims, start)) != std::string::npos)
{
tokens.push_back(text.substr(start, end - start));
start = text.find_first_not_of(delims, end);
}
if(start != std::string::npos)
tokens.push_back(text.substr(start));
return tokens;
}
C’est ma façon préférée de parcourir une chaîne. Vous pouvez faire ce que vous voulez par mot.
string line = "a line of text to iterate through";
string word;
istringstream iss(line, istringstream::in);
while( iss >> word )
{
// Do something on `word` here...
}
Ceci est similaire à Stack & nbsp; Question de débordement Comment tokeniser une chaîne en C ++? .
#include <iostream>
#include <string>
#include <boost/tokenizer.hpp>
using namespace std;
using namespace boost;
int main(int argc, char** argv)
{
string text = "token test\tstring";
char_separator<char> sep(" \t");
tokenizer<char_separator<char>> tokens(text, sep);
for (const string& t : tokens)
{
cout << t << "." << endl;
}
}
J'aime ce qui suit, car il place les résultats dans un vecteur, prend en charge une chaîne en tant que délimiteur et permet de contrôler la conservation des valeurs vides. Mais cela n’a pas l’air aussi bon.
#include <ostream>
#include <string>
#include <vector>
#include <algorithm>
#include <iterator>
using namespace std;
vector<string> split(const string& s, const string& delim, const bool keep_empty = true) {
vector<string> result;
if (delim.empty()) {
result.push_back(s);
return result;
}
string::const_iterator substart = s.begin(), subend;
while (true) {
subend = search(substart, s.end(), delim.begin(), delim.end());
string temp(substart, subend);
if (keep_empty || !temp.empty()) {
result.push_back(temp);
}
if (subend == s.end()) {
break;
}
substart = subend + delim.size();
}
return result;
}
int main() {
const vector<string> words = split("So close no matter how far", " ");
copy(words.begin(), words.end(), ostream_iterator<string>(cout, "\n"));
}
Bien sûr, Boost a un split () qui fonctionne partiellement comme ça. De plus, si vous utilisez "espace blanc", vous voulez vraiment dire n'importe quel type d'espace blanc, utiliser la division de Boost avec is_any_of () fonctionne très bien.
La LIST ne dispose pas encore d'une telle méthode.
Cependant, vous pouvez utiliser le strtok () fonctionne à l'aide de la std :: string :: c_str () , ou vous pouvez écrire le vôtre. Voici un exemple de code que j'ai trouvé après une recherche rapide dans Google ( "groupe de chaînes STL" ):
void Tokenize(const string& str,
vector<string>& tokens,
const string& delimiters = " ")
{
// 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);
}
}
Extrait de: http: // oopweb. com / CPP / Documents / CPPHOWTO / Volume / Programmation C ++ - HOWTO-7.html
Si vous avez des questions sur l'exemple de code, laissez un commentaire et je vais vous expliquer.
Et le fait de ne pas implémenter un typedef appelé itérateur ou surcharger l'opérateur < < ne signifie pas qu'il s'agit d'un code incorrect. J'utilise les fonctions C assez fréquemment. Par exemple, printf et scanf sont plus rapides que std :: cin et std :: cout (de manière significative), le fopen La syntaxe est beaucoup plus conviviale pour les types binaires, et ils ont également tendance à produire des fichiers EXE plus petits.
Ne vous vendez pas à l'aide de cet accord "L'élégance sur la performance" .
Voici une fonction divisée qui:
- est générique
- utilise le C ++ standard (pas de boost)
- accepte plusieurs délimiteurs
-
ignore les jetons vides (peut facilement être modifié)
template<typename T> vector<T> split(const T & str, const T & delimiters) { vector<T> v; typename T::size_type start = 0; auto pos = str.find_first_of(delimiters, start); while(pos != T::npos) { if(pos != start) // ignore empty tokens v.emplace_back(str, start, pos - start); start = pos + 1; pos = str.find_first_of(delimiters, start); } if(start < str.length()) // ignore trailing delimiter v.emplace_back(str, start, str.length() - start); // add what's left of the string return v; }
Exemple d'utilisation:
vector<string> v = split<string>("Hello, there; World", ";,");
vector<wstring> v = split<wstring>(L"Hello, there; World", L";,");
J'ai une solution à 2 lignes à ce problème:
char sep = ' ';
std::string s="1 This is an example";
for(size_t p=0, q=0; p!=s.npos; p=q)
std::cout << s.substr(p+(p!=0), (q=s.find(sep, p+1))-p-(p!=0)) << std::endl;
Ensuite, au lieu d’imprimer, vous pouvez le placer dans un vecteur.
Encore un autre moyen flexible et rapide
template<typename Operator>
void tokenize(Operator& op, const char* input, const char* delimiters) {
const char* s = input;
const char* e = s;
while (*e != 0) {
e = s;
while (*e != 0 && strchr(delimiters, *e) == 0) ++e;
if (e - s > 0) {
op(s, e - s);
}
s = e + 1;
}
}
Pour l'utiliser avec un vecteur de chaînes (Edit: Une personne ayant indiqué ne pas hériter des classes STL ... hrmf;)):
template<class ContainerType>
class Appender {
public:
Appender(ContainerType& container) : container_(container) {;}
void operator() (const char* s, unsigned length) {
container_.push_back(std::string(s,length));
}
private:
ContainerType& container_;
};
std::vector<std::string> strVector;
Appender v(strVector);
tokenize(v, "A number of words to be tokenized", " \t");
C'est ça! Et ce n’est qu’une façon d’utiliser le tokenizer, comme comment compter les mots:
class WordCounter {
public:
WordCounter() : noOfWords(0) {}
void operator() (const char*, unsigned) {
++noOfWords;
}
unsigned noOfWords;
};
WordCounter wc;
tokenize(wc, "A number of words to be counted", " \t");
ASSERT( wc.noOfWords == 7 );
Limité par l'imagination;)
Voici une solution simple qui utilise uniquement la bibliothèque de regex standard
#include <regex>
#include <string>
#include <vector>
std::vector<string> Tokenize( const string str, const std::regex regex )
{
using namespace std;
std::vector<string> result;
sregex_token_iterator it( str.begin(), str.end(), regex, -1 );
sregex_token_iterator reg_end;
for ( ; it != reg_end; ++it ) {
if ( !it->str().empty() ) //token could be empty:check
result.emplace_back( it->str() );
}
return result;
}
L'argument regex permet de rechercher plusieurs arguments (espaces, virgules, etc.)
Habituellement, je ne vérifie que la séparation des espaces et des virgules, de sorte que j'ai également cette fonction par défaut:
std::vector<string> TokenizeDefault( const string str )
{
using namespace std;
regex re( "[\\s,]+" );
return Tokenize( str, re );
}
Le "[\\ s,] + + recherche les espaces ( \\ s ) et les virgules (, ).
Remarque, si vous souhaitez fractionner wstring au lieu de chaîne ,
- remplacez
std :: regexparstd :: wregex - remplacez tous
sregex_token_iteratorparwsregex_token_iterator
Notez que vous pouvez également prendre l'argument chaîne par référence, selon votre compilateur.
Si vous aimez utiliser boost, mais souhaitez utiliser une chaîne entière comme séparateur (au lieu de caractères uniques comme dans la plupart des solutions proposées précédemment), vous pouvez utiliser boost_split_iterator .
Exemple de code comprenant un modèle pratique:
#include <iostream>
#include <vector>
#include <boost/algorithm/string.hpp>
template<typename _OutputIterator>
inline void split(
const std::string& str,
const std::string& delim,
_OutputIterator result)
{
using namespace boost::algorithm;
typedef split_iterator<std::string::const_iterator> It;
for(It iter=make_split_iterator(str, first_finder(delim, is_equal()));
iter!=It();
++iter)
{
*(result++) = boost::copy_range<std::string>(*iter);
}
}
int main(int argc, char* argv[])
{
using namespace std;
vector<string> splitted;
split("HelloFOOworldFOO!", "FOO", back_inserter(splitted));
// or directly to console, for example
split("HelloFOOworldFOO!", "FOO", ostream_iterator<string>(cout, "\n"));
return 0;
}
Utiliser std :: stringstream en tant que tel fonctionne parfaitement et fait exactement ce que vous voulez. Si vous cherchez simplement une façon différente de faire les choses, vous pouvez utiliser std :: find () / std :: find_first_of () et std :: string: : substr () .
Voici un exemple:
#include <iostream>
#include <string>
int main()
{
std::string s("Somewhere down the road");
std::string::size_type prev_pos = 0, pos = 0;
while( (pos = s.find(' ', pos)) != std::string::npos )
{
std::string substring( s.substr(prev_pos, pos-prev_pos) );
std::cout << substring << '\n';
prev_pos = ++pos;
}
std::string substring( s.substr(prev_pos, pos-prev_pos) ); // Last word
std::cout << substring << '\n';
return 0;
}
Il existe une fonction nommée strtok . .
#include<string>
using namespace std;
vector<string> split(char* str,const char* delim)
{
char* saveptr;
char* token = strtok_r(str,delim,&saveptr);
vector<string> result;
while(token != NULL)
{
result.push_back(token);
token = strtok_r(NULL,delim,&saveptr);
}
return result;
}
Voici une solution regex qui utilise uniquement la bibliothèque de regex standard. (Je suis un peu rouillé, il peut donc y avoir quelques erreurs de syntaxe, mais c'est au moins l'idée générale)
#include <regex.h>
#include <string.h>
#include <vector.h>
using namespace std;
vector<string> split(string s){
regex r ("\\w+"); //regex matches whole words, (greedy, so no fragment words)
regex_iterator<string::iterator> rit ( s.begin(), s.end(), r );
regex_iterator<string::iterator> rend; //iterators to iterate thru words
vector<string> result<regex_iterator>(rit, rend);
return result; //iterates through the matches to fill the vector
}
Le stringstream peut être pratique si vous devez analyser la chaîne de manière non symboles d'espace:
string s = "Name:JAck; Spouse:Susan; ...";
string dummy, name, spouse;
istringstream iss(s);
getline(iss, dummy, ':');
getline(iss, name, ';');
getline(iss, dummy, ':');
getline(iss, spouse, ';')
Jusqu'à présent, j'ai utilisé celui de Boost , mais j'avais besoin de quelque chose qui ne fonctionne pas. ne dépend pas de cela, alors je suis venu à ceci:
static void Split(std::vector<std::string>& lst, const std::string& input, const std::string& separators, bool remove_empty = true)
{
std::ostringstream word;
for (size_t n = 0; n < input.size(); ++n)
{
if (std::string::npos == separators.find(input[n]))
word << input[n];
else
{
if (!word.str().empty() || !remove_empty)
lst.push_back(word.str());
word.str("");
}
}
if (!word.str().empty() || !remove_empty)
lst.push_back(word.str());
}
Un bon point est que, dans les séparateurs , vous pouvez transmettre plusieurs caractères.
Court et élégant
#include <vector>
#include <string>
using namespace std;
vector<string> split(string data, string token)
{
vector<string> output;
size_t pos = string::npos; // size_t to avoid improbable overflow
do
{
pos = data.find(token);
output.push_back(data.substr(0, pos));
if (string::npos != pos)
data = data.substr(pos + token.size());
} while (string::npos != pos);
return output;
}
peut utiliser n’importe quelle chaîne comme délimiteur, mais aussi avec des données binaires (std :: string prend en charge les données binaires, y compris les valeurs NULL)
en utilisant:
auto a = split("this!!is!!!example!string", "!!");
sortie:
this
is
!example!string
J'ai moi-même roulé avec strtok et utilisé boost pour diviser une chaîne. La meilleure méthode que j'ai trouvée est la bibliothèque C ++ String Toolkit . Il est incroyablement flexible et rapide.
#include <iostream>
#include <vector>
#include <string>
#include <strtk.hpp>
const char *whitespace = " \t\r\n\f";
const char *whitespace_and_punctuation = " \t\r\n\f;,=";
int main()
{
{ // normal parsing of a string into a vector of strings
std::string s("Somewhere down the road");
std::vector<std::string> result;
if( strtk::parse( s, whitespace, result ) )
{
for(size_t i = 0; i < result.size(); ++i )
std::cout << result[i] << std::endl;
}
}
{ // parsing a string into a vector of floats with other separators
// besides spaces
std::string s("3.0, 3.14; 4.0");
std::vector<float> values;
if( strtk::parse( s, whitespace_and_punctuation, values ) )
{
for(size_t i = 0; i < values.size(); ++i )
std::cout << values[i] << std::endl;
}
}
{ // parsing a string into specific variables
std::string s("angle = 45; radius = 9.9");
std::string w1, w2;
float v1, v2;
if( strtk::parse( s, whitespace_and_punctuation, w1, v1, w2, v2) )
{
std::cout << "word " << w1 << ", value " << v1 << std::endl;
std::cout << "word " << w2 << ", value " << v2 << std::endl;
}
}
return 0;
}
La boîte à outils offre beaucoup plus de souplesse que ce que montre cet exemple simple, mais son utilité pour analyser une chaîne en éléments utiles est incroyable.
J'ai créé ceci parce que j'avais besoin d'un moyen facile de séparer des chaînes et des chaînes basées sur c ... J'espère que quelqu'un d'autre pourra le trouver utile également. En outre, il ne repose pas sur les jetons et vous pouvez utiliser les champs comme délimiteurs, ce qui est une autre clé dont j'avais besoin.
Je suis sûr qu'il y a des améliorations à apporter pour améliorer encore son élégance et le faire par tous les moyens
StringSplitter.hpp:
#include <vector>
#include <iostream>
#include <string.h>
using namespace std;
class StringSplit
{
private:
void copy_fragment(char*, char*, char*);
void copy_fragment(char*, char*, char);
bool match_fragment(char*, char*, int);
int untilnextdelim(char*, char);
int untilnextdelim(char*, char*);
void assimilate(char*, char);
void assimilate(char*, char*);
bool string_contains(char*, char*);
long calc_string_size(char*);
void copy_string(char*, char*);
public:
vector<char*> split_cstr(char);
vector<char*> split_cstr(char*);
vector<string> split_string(char);
vector<string> split_string(char*);
char* String;
bool do_string;
bool keep_empty;
vector<char*> Container;
vector<string> ContainerS;
StringSplit(char * in)
{
String = in;
}
StringSplit(string in)
{
size_t len = calc_string_size((char*)in.c_str());
String = new char[len + 1];
memset(String, 0, len + 1);
copy_string(String, (char*)in.c_str());
do_string = true;
}
~StringSplit()
{
for (int i = 0; i < Container.size(); i++)
{
if (Container[i] != NULL)
{
delete[] Container[i];
}
}
if (do_string)
{
delete[] String;
}
}
};
StringSplitter.cpp:
#include <string.h>
#include <iostream>
#include <vector>
#include "StringSplit.hpp"
using namespace std;
void StringSplit::assimilate(char*src, char delim)
{
int until = untilnextdelim(src, delim);
if (until > 0)
{
char * temp = new char[until + 1];
memset(temp, 0, until + 1);
copy_fragment(temp, src, delim);
if (keep_empty || *temp != 0)
{
if (!do_string)
{
Container.push_back(temp);
}
else
{
string x = temp;
ContainerS.push_back(x);
}
}
else
{
delete[] temp;
}
}
}
void StringSplit::assimilate(char*src, char* delim)
{
int until = untilnextdelim(src, delim);
if (until > 0)
{
char * temp = new char[until + 1];
memset(temp, 0, until + 1);
copy_fragment(temp, src, delim);
if (keep_empty || *temp != 0)
{
if (!do_string)
{
Container.push_back(temp);
}
else
{
string x = temp;
ContainerS.push_back(x);
}
}
else
{
delete[] temp;
}
}
}
long StringSplit::calc_string_size(char* _in)
{
long i = 0;
while (*_in++)
{
i++;
}
return i;
}
bool StringSplit::string_contains(char* haystack, char* needle)
{
size_t len = calc_string_size(needle);
size_t lenh = calc_string_size(haystack);
while (lenh--)
{
if (match_fragment(haystack + lenh, needle, len))
{
return true;
}
}
return false;
}
bool StringSplit::match_fragment(char* _src, char* cmp, int len)
{
while (len--)
{
if (*(_src + len) != *(cmp + len))
{
return false;
}
}
return true;
}
int StringSplit::untilnextdelim(char* _in, char delim)
{
size_t len = calc_string_size(_in);
if (*_in == delim)
{
_in += 1;
return len - 1;
}
int c = 0;
while (*(_in + c) != delim && c < len)
{
c++;
}
return c;
}
int StringSplit::untilnextdelim(char* _in, char* delim)
{
int s = calc_string_size(delim);
int c = 1 + s;
if (!string_contains(_in, delim))
{
return calc_string_size(_in);
}
else if (match_fragment(_in, delim, s))
{
_in += s;
return calc_string_size(_in);
}
while (!match_fragment(_in + c, delim, s))
{
c++;
}
return c;
}
void StringSplit::copy_fragment(char* dest, char* src, char delim)
{
if (*src == delim)
{
src++;
}
int c = 0;
while (*(src + c) != delim && *(src + c))
{
*(dest + c) = *(src + c);
c++;
}
*(dest + c) = 0;
}
void StringSplit::copy_string(char* dest, char* src)
{
int i = 0;
while (*(src + i))
{
*(dest + i) = *(src + i);
i++;
}
}
void StringSplit::copy_fragment(char* dest, char* src, char* delim)
{
size_t len = calc_string_size(delim);
size_t lens = calc_string_size(src);
if (match_fragment(src, delim, len))
{
src += len;
lens -= len;
}
int c = 0;
while (!match_fragment(src + c, delim, len) && (c < lens))
{
*(dest + c) = *(src + c);
c++;
}
*(dest + c) = 0;
}
vector<char*> StringSplit::split_cstr(char Delimiter)
{
int i = 0;
while (*String)
{
if (*String != Delimiter && i == 0)
{
assimilate(String, Delimiter);
}
if (*String == Delimiter)
{
assimilate(String, Delimiter);
}
i++;
String++;
}
String -= i;
delete[] String;
return Container;
}
vector<string> StringSplit::split_string(char Delimiter)
{
do_string = true;
int i = 0;
while (*String)
{
if (*String != Delimiter && i == 0)
{
assimilate(String, Delimiter);
}
if (*String == Delimiter)
{
assimilate(String, Delimiter);
}
i++;
String++;
}
String -= i;
delete[] String;
return ContainerS;
}
vector<char*> StringSplit::split_cstr(char* Delimiter)
{
int i = 0;
size_t LenDelim = calc_string_size(Delimiter);
while(*String)
{
if (!match_fragment(String, Delimiter, LenDelim) && i == 0)
{
assimilate(String, Delimiter);
}
if (match_fragment(String, Delimiter, LenDelim))
{
assimilate(String,Delimiter);
}
i++;
String++;
}
String -= i;
delete[] String;
return Container;
}
vector<string> StringSplit::split_string(char* Delimiter)
{
do_string = true;
int i = 0;
size_t LenDelim = calc_string_size(Delimiter);
while (*String)
{
if (!match_fragment(String, Delimiter, LenDelim) && i == 0)
{
assimilate(String, Delimiter);
}
if (match_fragment(String, Delimiter, LenDelim))
{
assimilate(String, Delimiter);
}
i++;
String++;
}
String -= i;
delete[] String;
return ContainerS;
}
Exemples:
int main(int argc, char*argv[])
{
StringSplit ss = "This:CUT:is:CUT:an:CUT:example:CUT:cstring";
vector<char*> Split = ss.split_cstr(":CUT:");
for (int i = 0; i < Split.size(); i++)
{
cout << Split[i] << endl;
}
return 0;
}
affichera:
Ce
est
un
exemple
cstring
int main(int argc, char*argv[])
{
StringSplit ss = "This:is:an:example:cstring";
vector<char*> Split = ss.split_cstr(':');
for (int i = 0; i < Split.size(); i++)
{
cout << Split[i] << endl;
}
return 0;
}
int main(int argc, char*argv[])
{
string mystring = "This[SPLIT]is[SPLIT]an[SPLIT]example[SPLIT]string";
StringSplit ss = mystring;
vector<string> Split = ss.split_string("[SPLIT]");
for (int i = 0; i < Split.size(); i++)
{
cout << Split[i] << endl;
}
return 0;
}
int main(int argc, char*argv[])
{
string mystring = "This|is|an|example|string";
StringSplit ss = mystring;
vector<string> Split = ss.split_string('|');
for (int i = 0; i < Split.size(); i++)
{
cout << Split[i] << endl;
}
return 0;
}
Pour conserver les entrées vides (par défaut, les espaces vides seront exclus):
StringSplit ss = mystring;
ss.keep_empty = true;
vector<string> Split = ss.split_string(":DELIM:");
Le but était de la rendre similaire à la méthode Split () de C #, dans laquelle fractionner une chaîne est aussi simple que:
String[] Split =
"Hey:cut:what's:cut:your:cut:name?".Split(new[]{":cut:"}, StringSplitOptions.None);
foreach(String X in Split)
{
Console.Write(X);
}
J'espère que quelqu'un d'autre trouvera cela aussi utile que moi.
Qu'en est-il de cela:
#include <string>
#include <vector>
using namespace std;
vector<string> split(string str, const char delim) {
vector<string> v;
string tmp;
for(string::const_iterator i; i = str.begin(); i <= str.end(); ++i) {
if(*i != delim && i != str.end()) {
tmp += *i;
} else {
v.push_back(tmp);
tmp = "";
}
}
return v;
}
Voici une autre façon de le faire ..
void split_string(string text,vector<string>& words)
{
int i=0;
char ch;
string word;
while(ch=text[i++])
{
if (isspace(ch))
{
if (!word.empty())
{
words.push_back(word);
}
word = "";
}
else
{
word += ch;
}
}
if (!word.empty())
{
words.push_back(word);
}
}
J'aime utiliser les méthodes boost / regex pour cette tâche car elles offrent une flexibilité maximale pour la spécification des critères de fractionnement.
#include <iostream>
#include <string>
#include <boost/regex.hpp>
int main() {
std::string line("A:::line::to:split");
const boost::regex re(":+"); // one or more colons
// -1 means find inverse matches aka split
boost::sregex_token_iterator tokens(line.begin(),line.end(),re,-1);
boost::sregex_token_iterator end;
for (; tokens != end; ++tokens)
std::cout << *tokens << std::endl;
}
Récemment, j’ai dû scinder un mot cameleur en sous-mots. Il n'y a pas de délimiteurs, juste des caractères supérieurs.
#include <string>
#include <list>
#include <locale> // std::isupper
template<class String>
const std::list<String> split_camel_case_string(const String &s)
{
std::list<String> R;
String w;
for (String::const_iterator i = s.begin(); i < s.end(); ++i) { {
if (std::isupper(*i)) {
if (w.length()) {
R.push_back(w);
w.clear();
}
}
w += *i;
}
if (w.length())
R.push_back(w);
return R;
}
Par exemple, cela divise "AQueryTrades". dans "A", "Query" et "Trades". La fonction fonctionne avec des chaînes étroites et larges. Dans la mesure où il respecte les paramètres régionaux actuels, il est scindé en "RaumfahrtÜberwachungsVerordnung". into "Raumfahrt", "Überwachungs" et "Verordnung".
Remarque std :: upper doit être réellement passé en tant qu'argument de modèle de fonction. Ensuite, le plus généralisé de cette fonction peut se diviser en délimiteurs tels que "," , "," ou ". " aussi.
#include<iostream>
#include<string>
#include<sstream>
#include<vector>
using namespace std;
vector<string> split(const string &s, char delim) {
vector<string> elems;
stringstream ss(s);
string item;
while (getline(ss, item, delim)) {
elems.push_back(item);
}
return elems;
}
int main() {
vector<string> x = split("thi is an sample test",' ');
unsigned int i;
for(i=0;i<x.size();i++)
cout<<i<<":"<<x[i]<<endl;
return 0;
}
Cette réponse prend la chaîne et la met dans un vecteur de chaînes. Il utilise la bibliothèque de boost.
#include <boost/algorithm/string.hpp>
std::vector<std::string> strs;
boost::split(strs, "string to split", boost::is_any_of("\t "));
Obtenez Boost ! : -)
#include <boost/algorithm/string/split.hpp>
#include <boost/algorithm/string.hpp>
#include <iostream>
#include <vector>
using namespace std;
using namespace boost;
int main(int argc, char**argv) {
typedef vector < string > list_type;
list_type list;
string line;
line = "Somewhere down the road";
split(list, line, is_any_of(" "));
for(int i = 0; i < list.size(); i++)
{
cout << list[i] << endl;
}
return 0;
}
Cet exemple donne la sortie -
Somewhere
down
the
road
