Comment vérifier si une chaîne contient des espaces/onglets/nouvelles lignes (tout ce qui est vide)?

Je sais qu'il y a un "isspace" fonction qui vérifie pour les espaces, mais cela m'obligerait à parcourir chaque caractère dans la chaîne, ce qui peut être mauvais sur les performances puisque ce serait un lot. Est-il un moyen rapide de vérifier si une std::string ne contient que des espaces?

ex:

function("       ") //returns true
function("    4  ") //returns false

Une solution, j'ai pensé est d'utiliser des regex, je saurai qu'il ne contient que des espaces si c'est faux... mais je ne suis pas si sûr que ce serait plus efficace que la isspace fonction.

regex: [\w\W] //checks for any word character(a,b,c..) and non-word character([,],..)

merci d'avance!

"qui m'obligerait à parcourir chaque caractère dans la chaîne, ce qui peut être mauvais sur les performances" Comment envisagez-vous de tester si tous les caractères correspondent à vos critères de sans itération sur tous les caractères dans la chaîne?
Ne vous inquiétez pas au sujet de micro-optimisation jusqu'à ce que votre solution est en ordre de marche.
À ma connaissance il n'est pas possible de voir si une chaîne contient des espaces, sans vérifier si chaque caractère est un espace, il ne peut pas être fait n'importe quel plus rapide, sauf si vous en trouver un non-espace vous renvoie false là et puis au lieu de vérifier le reste de la chaîne.
Vous pouvez consulter le système de temps avant et après les appels avec chaque fonction pour déterminer lequel est le plus rapide.
Oui, les gars, vous êtes de droite 😛

OriginalL'auteur unwise guy | 2012-07-11

c++

7

Tout de la méthode, de la nécessité, le besoin de regarder à chaque caractère de la chaîne. Une boucle qui appelle isspace() sur chaque personnage est assez efficace. Si isspace() est incorporé par le compilateur, ce serait sacrément près optimale.

La boucle doit, bien sûr, abandonner dès qu'un caractère non espace est vu.

Je comprends maintenant, va accepter en 10 min 🙂

OriginalL'auteur Ernest Friedman-Hill
8

Avec une chaîne, le meilleur que vous pouvez faire sera de la forme:
```
return string::find_first_not_of("\t\n ") == string::npos;
```
Ce sera en O(n) dans le pire des cas, mais sans savoir d'autre au sujet de la chaîne, ce sera le meilleur que vous pouvez faire.

ce n'est pas nécessairement le meilleur que vous pouvez faire. Voir mon commentaire.
if (b) return true; return false; devrait être écrit return b;.
Avec un std::string. Si vous vouliez mettre en œuvre votre idée, vous devriez envelopper d'une std::string dans une autre classe comme cached_string ou quelque chose de similaire. Si c'est une option, puis par tous signifie que votre idée est plus rapide.
En effet. Édité pour corriger ça (stupide) de la surveillance.
oui, c'est l'idée. Comme je l'ai dit, cela dépend vraiment si ça vaut la complexité, ce qui est fort probable qu'il ne l'est pas 🙂

OriginalL'auteur Yuushi
2

Vous faites l'hypothèse regex ne marche pas itérer sur la chaîne. Regex est probablement beaucoup plus lourd qu'un linéaire de recherche, car il peut créer un FSM et parcourir sur cette base.

Le seul moyen pour accélérer davantage et d'en faire un quasi-constante de temps de l'opération est d'amortir le coût par itération sur chaque mise à jour de la chaîne et de la mise en cache un bool/bit qui suit si il y a un espace, de caractères, de retour de cette valeur, si aucun changement n'a été fait depuis, et la mise à jour que peu à chaque fois que vous effectuez une opération d'écriture à cette chaîne. Cependant, cette sacrifices/ralentit la vitesse de modification des opérations dans le but d'augmenter la vitesse de votre personnalisé has_space().

Nit: isspace a de la constante de temps de la complexité, car il ne teste que d'un seul caractère. Une boucle de test de chaque personnage avec isspace aurait linéaire de la complexité.
ah. Je pensais que c'était une opération de chaîne. Sera mise à jour. merci.

OriginalL'auteur Preet Kukreti

Pour ce que ça vaut, une localité est une fonction (scan_is) pour faire des choses comme ça:

#include <locale>
#include <iostream>
#include <iomanip>

int main() {

    std::string inputs[] = { 
        "all lower",
        "including a space"
    };

    std::locale loc(std::locale::classic());

    std::ctype_base::mask m = std::ctype_base::space;

    for (int i=0; i<2; i++) {
        char const *pos;
        char const *b = &*inputs[i].begin();
        char const *e = &*inputs[i].end();

        std::cout << "Input: " << std::setw(20) << inputs[i] << ":\t";
        if ((pos=std::use_facet<std::ctype<char> >(loc).scan_is(m, b, e)) == e)
            std::cout << "No space character\n";
        else
            std::cout << "First space character at position " << pos - b << "\n";
    }
    return 0;
}

C'est probablement ouvert à un peu (beaucoup) question de savoir si cela donne beaucoup (le cas échéant) de réel avantage par rapport à l'aide isspace dans une boucle (ou à l'aide de std::find_if).

OriginalL'auteur Jerry Coffin

Vous pouvez également utiliser find_first_not_of si vous êtes tous les caractères de l'être dans une liste donnée.
Ensuite, vous pouvez éviter les boucles.

Voici un exemple

#include <string>
#include <algorithm>
using namespace std;
int main()
{
    string str1="      ";
    string str2="      u    ";
    bool ContainsNotBlank1=(str1.find_first_not_of("\t\n ")==string::npos);
    bool ContainsNotBlank2=(str2.find_first_not_of("\t\n ")==string::npos);
    bool ContainsNotBlank3=(str2.find_first_not_of("\t\n u")==string::npos);
    cout << ContainsNotBlank1 <<endl;
    cout << ContainsNotBlank2 <<endl;
    cout << ContainsNotBlank3 <<endl;
    return 0;
}

De sortie:
1: parce que seuls les blancs et un onglet
0: car u n'est pas dans la liste "\t\n"
1: parce que str2 contient des espaces, des tabulations et des u.

J'espère que ça aide
Dites-moi si vous avez des questions

OriginalL'auteur Gabriel

Vous devez vous connecter pour publier un commentaire.