Retrait d'attaque et de fuite des espaces à partir d'une chaîne

Ceci est appelé ajustement. Si vous pouvez utiliser Boost, je le recommande.

Sinon, utilisez find_first_not_of pour obtenir l'index du premier caractère non-blanc, puis find_last_not_of pour obtenir l'index à partir de la fin qui n'est pas un espace. Avec ces derniers, l'utilisation substr pour obtenir la sous-chaîne avec pas environnant les espaces.

En réponse à votre montage, je ne connais pas le terme, mais je suppose que quelque chose le long des lignes de "réduire", c'est ce que je l'ai appelé. 🙂 (Remarque, j'ai modifié le blanc-espace à un paramètre, pour la souplesse)

#include <iostream>
#include <string>
std::string trim(const std::string& str,
const std::string& whitespace = " \t")
{
const auto strBegin = str.find_first_not_of(whitespace);
if (strBegin == std::string::npos)
return ""; //no content
const auto strEnd = str.find_last_not_of(whitespace);
const auto strRange = strEnd - strBegin + 1;
return str.substr(strBegin, strRange);
}
std::string reduce(const std::string& str,
const std::string& fill = " ",
const std::string& whitespace = " \t")
{
//trim first
auto result = trim(str, whitespace);
//replace sub ranges
auto beginSpace = result.find_first_of(whitespace);
while (beginSpace != std::string::npos)
{
const auto endSpace = result.find_first_not_of(whitespace, beginSpace);
const auto range = endSpace - beginSpace;
result.replace(beginSpace, range, fill);
const auto newStart = beginSpace + fill.length();
beginSpace = result.find_first_of(whitespace, newStart);
}
return result;
}
int main(void)
{
const std::string foo = "    too much\t   \tspace\t\t\t  ";
const std::string bar = "one\ntwo";
std::cout << "[" << trim(foo) << "]" << std::endl;
std::cout << "[" << reduce(foo) << "]" << std::endl;
std::cout << "[" << reduce(foo, "-") << "]" << std::endl;
std::cout << "[" << trim(bar) << "]" << std::endl;
}

Résultat:

[too much               space]  
[too much space]  
[too-much-space]  
[one  
two]  

Je suis actuellement en utilisant ces fonctions:

//trim from left
inline std::string& ltrim(std::string& s, const char* t = " \t\n\r\f\v")
{
s.erase(0, s.find_first_not_of(t));
return s;
}
//trim from right
inline std::string& rtrim(std::string& s, const char* t = " \t\n\r\f\v")
{
s.erase(s.find_last_not_of(t) + 1);
return s;
}
//trim from left & right
inline std::string& trim(std::string& s, const char* t = " \t\n\r\f\v")
{
return ltrim(rtrim(s, t), t);
}
//copying versions
inline std::string ltrim_copy(std::string s, const char* t = " \t\n\r\f\v")
{
return ltrim(s, t);
}
inline std::string rtrim_copy(std::string s, const char* t = " \t\n\r\f\v")
{
return rtrim(s, t);
}
inline std::string trim_copy(std::string s, const char* t = " \t\n\r\f\v")
{
return trim(s, t);
}

Ici est de savoir comment vous pouvez le faire:

std::string & trim(std::string & str)
{
return ltrim(rtrim(str));
}

Et les fonctions de soutien sont mis en oeuvre comme:

std::string & ltrim(std::string & str)
{
auto it2 =  std::find_if( str.begin() , str.end() , [](char ch){ return !std::isspace<char>(ch , std::locale::classic() ) ; } );
str.erase( str.begin() , it2);
return str;   
}
std::string & rtrim(std::string & str)
{
auto it1 =  std::find_if( str.rbegin() , str.rend() , [](char ch){ return !std::isspace<char>(ch , std::locale::classic() ) ; } );
str.erase( it1.base() , str.end() );
return str;   
}

Et une fois que vous avez toutes ces à la place, vous pouvez écrire ceci:

std::string trim_copy(std::string const & str)
{
auto s = str;
return ltrim(rtrim(s));
}

Essayer cette

C'est ma solution pour le décapage de l'attaque et de fuite des espaces ...

std::string stripString = "  Plamen     ";
while(!stripString.empty() && std::isspace(*stripString.begin()))
stripString.erase(stripString.begin());
while(!stripString.empty() && std::isspace(*stripString.rbegin()))
stripString.erase(stripString.length()-1);

Le résultat est "Plamen"

À l'aide de la bibliothèque standard a beaucoup d'avantages, mais il faut être conscient de certains cas spéciaux qui causent des exceptions. Par exemple, aucune des réponses vise le cas où une chaîne C++ a certains caractères Unicode. Dans ce cas, si vous utilisez la fonction isspace, une exception sera levée.

J'ai été en utilisant le code suivant pour couper les cordes et certaines autres opérations qui pourraient venir dans maniable. Les principaux avantages de ce code sont les suivantes: il est vraiment très rapide (plus rapide que n'importe quel code je n'ai jamais testé), il n'utilise que la bibliothèque standard, et il n'a jamais provoque une exception:

#include <string>
#include <algorithm>
#include <functional>
#include <locale>
#include <iostream>
typedef unsigned char BYTE;
std::string strTrim(std::string s, char option = 0)
{
//convert all whitespace characters to a standard space
std::replace_if(s.begin(), s.end(), (std::function<int(BYTE)>)::isspace, ' ');
//remove leading and trailing spaces
size_t f = s.find_first_not_of(' ');
if (f == std::string::npos) return "";
s = s.substr(f, s.find_last_not_of(' ') - f + 1);
//remove consecutive spaces
s = std::string(s.begin(), std::unique(s.begin(), s.end(),
[](BYTE l, BYTE r){ return l == ' ' && r == ' '; }));
switch (option)
{
case 'l':  //convert to lowercase
std::transform(s.begin(), s.end(), s.begin(), ::tolower);
return s;
case 'U':  //convert to uppercase
std::transform(s.begin(), s.end(), s.begin(), ::toupper);
return s;
case 'n':  //remove all spaces
s.erase(std::remove(s.begin(), s.end(), ' '), s.end());
return s;
default: //just trim
return s;
}
}

J'ai testé, cela fonctionne. Donc cette méthode processInput vais juste demander à l'utilisateur de taper quelque chose dans. il sera de retour une chaîne qui a pas d'espace supplémentaire à l'interne, ni des espaces au début ou à la fin. Espérons que cette aide. (d'ailleurs mis un tas de commentaires de rendre plus simple à comprendre).

vous pouvez voir comment le mettre en œuvre dans le main() en bas

#include <string>
#include <iostream>
string processInput() {
char inputChar[256];
string output = "";
int outputLength = 0;
bool space = false;
//user inputs a string.. well a char array
cin.getline(inputChar,256);
output = inputChar;
string outputToLower = "";
//put characters to lower and reduce spaces
for(int i = 0; i < output.length(); i++){
//if it's caps put it to lowercase
output[i] = tolower(output[i]);
//make sure we do not include tabs or line returns or weird symbol for null entry array thingy
if (output[i] != '\t' && output[i] != '\n' && output[i] != 'Ì') {
if (space) {
//if the previous space was a space but this one is not, then space now is false and add char
if (output[i] != ' ') {
space = false;
//add the char
outputToLower+=output[i];
}
} else {
//if space is false, make it true if the char is a space
if (output[i] == ' ') {
space = true;
}
//add the char
outputToLower+=output[i];
}
}
}
//trim leading and tailing space
string trimmedOutput = "";
for(int i = 0; i < outputToLower.length(); i++){
//if it's the last character and it's not a space, then add it
//if it's the first character and it's not a space, then add it
//if it's not the first or the last then add it
if (i == outputToLower.length() - 1 && outputToLower[i] != ' ' || 
i == 0 && outputToLower[i] != ' ' || 
i > 0 && i < outputToLower.length() - 1) {
trimmedOutput += outputToLower[i];
} 
}
//return
output = trimmedOutput;
return output;
}
int main() {
cout << "Username: ";
string userName = processInput();
cout << "\nModified Input = " << userName << endl;
}

Pourquoi compliquer?

std::string removeSpaces(std::string x){
if(x[0] == ' '){ x.erase(0, 1); }
if(x[x.length()-1] == ' '){ x.erase(x.length()-1, x.length()); }
return x;
}

Cela fonctionne même si le boost est à l'échec, pas de regex, pas de trucs bizarres, ni les bibliothèques.

void removeSpaces(string& str)
{
/* remove multiple spaces */
int k=0;
for (int j=0; j<str.size(); ++j)
{
if ( (str[j] != ' ') || (str[j] == ' ' && str[j+1] != ' ' ))
{
str [k] = str [j];
++k;
}
}
str.resize(k);
/* remove space at the end */   
if (str [k-1] == ' ')
str.erase(str.end()-1);
/* remove space at the begin */
if (str [0] == ' ')
str.erase(str.begin());
}

Pour le leader et les espaces de fin, que diriez-vous:

string string_trim(const string& in) {
stringstream ss;
string out;
ss << in;
ss >> out;
return out;
}

Ou pour une phrase:

string trim_words(const string& sentence) {
stringstream ss;
ss << sentence;
string s;
string out;
while(ss >> s) {
out+=(s+' ');
}
return out.substr(0, out.length()-1);
}

Pas boost, pas de regex, juste le string de la bibliothèque. C'est aussi simple que cela.

string trim(const string s) { //removes whitespace characters from beginnig and end of string s
string x = s;
for(int i=0; i<(int)s.length(); i++) {
const int l = (int)x.length()-1;
if(x[l]==' '||x[l]=='\t'||x[l]=='\n'||x[l]=='\v'||x[l]=='\f'||x[l]=='\r'||x[l]=='\0') x.erase(l, 1);
if(x[0]==' '||x[0]=='\t'||x[0]=='\n'||x[0]=='\v'||x[0]=='\f'||x[0]=='\r'||x[0]=='\0') x.erase(0, 1);
}
return x;
}

Ma Solution pour ce problème qui n'utilisent pas toute STL méthodes, mais seulement C++ string propres méthodes est le suivant：

void processString(string &s) {
if ( s.empty() ) return;
//delete leading and trailing spaces of the input string
int notSpaceStartPos = 0, notSpaceEndPos = s.length() - 1;
while ( s[notSpaceStartPos] == ' ' ) ++notSpaceStartPos;
while ( s[notSpaceEndPos] == ' ' ) --notSpaceEndPos;
if ( notSpaceStartPos > notSpaceEndPos ) { s = ""; return; }
s = s.substr(notSpaceStartPos, notSpaceEndPos - notSpaceStartPos + 1);
//reduce multiple spaces between two words to a single space 
string temp;
for ( int i = 0; i < s.length(); i++ ) {
if ( i > 0 && s[i] == ' ' && s[i-1] == ' ' ) continue;
temp.push_back(s[i]);
}
s = temp;
}

J'ai utilisé cette méthode pour passer un LeetCode problème Inverser les Mots dans une Chaîne de caractères