C++: est une chaîne de caractère.empty() toujours équivalent à la chaîne == “”?

Puis-je faire une hypothèse que, compte tenu de

std::string str;
... //do something to str

Est la déclaration suivante est toujours vraie?

(str.empty() == (str == ""))

str.empty() est plus général. Si un jour vous décidez d'utiliser std::wstring str puis str.empty() va fonctionner, mais str == "" ne sera même pas compiler.

InformationsquelleAutor Michael | 2009-01-27

c++string

52

Réponse

Oui. Voici la mise en œuvre de bits/basic_string.h, le code de basic_string<_CharT, _Traits, _Alloc>:
```
  /**
   *  Returns true if the %string is empty.  Equivalent to *this == "".
   */
  bool
  empty() const
  { return this->size() == 0; }
```
Discussion

Même si les deux formes sont équivalentes pour std::string, vous peut souhaitez utiliser .empty() parce qu'il est plus général.

En effet, J. F. Sebastian commentaires que si vous passez à l'aide de std::wstring au lieu de std::string, puis =="" n'aurez même pas compiler, parce que vous ne pouvez pas comparer une chaîne de wchar_t avec l'un de char. Ceci, cependant, ne sont pas directement liées à votre question de départ, et je suis à 99% sûr que vous ne serez pas passer à std::wstring.
- La réponse à la question d'origine, qui ne demandait qu'à propos de std::string, est clairement "oui".
- Aussi, empty() pourrait être plus efficace que l' =="".
- cela répond semble très compilateur/vendor spécifiques à moi pour une raison quelconque
- C'est vrai. Mais @D. Shawley montre que c'est en ligne avec la norme.
- Rex: ce Qui signifie que sa réponse est celle qui devrait être voté, et pas le vôtre. 😉 En C++, c'est une erreur de faire confiance à votre compilateur/mise en œuvre de dire quelque chose sur la façon dont le langage doit se comporter. Tout ce qu'il peut vous dire, c'est comment votre de la mise en œuvre se comporte pas de savoir si ce comportement est 1) corriger, et 2) sont requis.
- Ne soyez pas si sûr de ne pas passer à std::wstring. Vous ne savez jamais quand corporate HQ voulez ouvrir un Japonais d'affiliation.
InformationsquelleAutor A. Rex
11

Il devrait être. La norme ANSI/ISO standard unis dans 21.3.3 basic_string de la capacité:

size_type size() const;

Retourne: un nombre de char comme des objets actuellement dans la chaîne.

bool empty() const;

Retourne: size() == 0

Toutefois, à l'article 18 de 21.3.1 basic_string constructeurs il affirme que le personnage-type de la cession de l'opérateur utilise traits::length() pour établir la durée de la séquence contrôlée donc, vous pourriez vous retrouver avec quelque chose d'étrange si vous utilisez une autre spécialisation de std::basic_string<>.

Je pense que le 100% de réponses correctes est que
```
(str.empty() == (str == std::string()))
```
ou quelque chose comme ça. Si vous n'avez pas fait quelque chose d'étrange, alors std::string("") et std::string() doit être équivalent

Ils sont logiquement similaire, mais ils sont à l'essai pour différentes choses. str.empty() est de vérifier si la chaîne est vide, où l'autre est la vérification de l'égalité à l'encontre d'un style C chaîne vide. Je voudrais utiliser celle qui est la plus appropriée pour ce que vous essayez de faire. Si vous voulez savoir si une chaîne est vide, puis utilisez str.empty().

InformationsquelleAutor D.Shawley
7

str.empty() n'est jamais plus lent, mais peut-être plus rapide que str == "". Cela dépend de la mise en œuvre. Donc, vous devriez utiliser str.empty() juste au cas où.

C'est un peu comme utiliser ++i au lieu de i++ pour augmenter un compteur (en supposant que vous n'avez pas besoin du résultat de l'opérateur d'incrémentation lui-même). Votre compilateur peut optimiser, mais vous ne perdez rien pour l'aide ++i, et peut-être remporter quelque chose, alors vous êtes mieux de les utiliser ++i.

En dehors de problèmes de performances, la réponse à votre question est oui; les deux expressions sont logiquement équivalentes.

InformationsquelleAutor Gorpik

Oui (str.empty() == (str == "")) est toujours* vrai pour std::string. Mais n'oubliez pas que string peut contenir '\0' caractères. Ainsi, même si l'expression s == "" peut-être faux, s.c_str() peut toujours renvoyer un vide C-string. Par exemple:

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

void test( const string & s ) {
    bool bempty = s.empty();
    bool beq = std::operator==(s, ""); //avoid global namespace operator==
    const char * res = (bempty == beq ) ? "PASS" : "FAIL";
    const char * isempty = bempty ? "    empty " : "NOT empty ";
    const char * iseq = beq ? "    == \"\"" : "NOT == \"\"";
    cout << res << " size=" << s.size();
    cout << " c_str=\"" << s.c_str() << "\" ";
    cout << isempty << iseq << endl;
}

int main() {
    string s;          test(s); //PASS size=0 c_str=""     empty     == ""
    s.push_back('#include <string>
#include <iostream>
using namespace std;
void test( const string & s ) {
bool bempty = s.empty();
bool beq = std::operator==(s, ""); //avoid global namespace operator==
const char * res = (bempty == beq ) ? "PASS" : "FAIL";
const char * isempty = bempty ? "    empty " : "NOT empty ";
const char * iseq = beq ? "    == \"\"" : "NOT == \"\"";
cout << res << " size=" << s.size();
cout << " c_str=\"" << s.c_str() << "\" ";
cout << isempty << iseq << endl;
}
int main() {
string s;          test(s); //PASS size=0 c_str=""     empty     == ""
s.push_back('\0'); test(s); //PASS size=1 c_str="" NOT empty NOT == ""
s.push_back('x');  test(s); //PASS size=2 c_str="" NOT empty NOT == ""
s.push_back('\0'); test(s); //PASS size=3 c_str="" NOT empty NOT == ""
s.push_back('y');  test(s); //PASS size=4 c_str="" NOT empty NOT == ""
return 0;
}
'); test(s); //PASS size=1 c_str="" NOT empty NOT == ""
    s.push_back('x');  test(s); //PASS size=2 c_str="" NOT empty NOT == ""
    s.push_back('#include <string>
#include <iostream>
using namespace std;
void test( const string & s ) {
bool bempty = s.empty();
bool beq = std::operator==(s, ""); //avoid global namespace operator==
const char * res = (bempty == beq ) ? "PASS" : "FAIL";
const char * isempty = bempty ? "    empty " : "NOT empty ";
const char * iseq = beq ? "    == \"\"" : "NOT == \"\"";
cout << res << " size=" << s.size();
cout << " c_str=\"" << s.c_str() << "\" ";
cout << isempty << iseq << endl;
}
int main() {
string s;          test(s); //PASS size=0 c_str=""     empty     == ""
s.push_back('\0'); test(s); //PASS size=1 c_str="" NOT empty NOT == ""
s.push_back('x');  test(s); //PASS size=2 c_str="" NOT empty NOT == ""
s.push_back('\0'); test(s); //PASS size=3 c_str="" NOT empty NOT == ""
s.push_back('y');  test(s); //PASS size=4 c_str="" NOT empty NOT == ""
return 0;
}
'); test(s); //PASS size=3 c_str="" NOT empty NOT == ""
    s.push_back('y');  test(s); //PASS size=4 c_str="" NOT empty NOT == ""
    return 0;
}

**limitation de surcharge de operator== dans l'espace de noms global, comme d'autres l'ont mentionné*

InformationsquelleAutor jwfearn

1

Certaines implémentations peuvent tester la valeur null comme premier caractère dans la chaîne résultant en une légère augmentation de la vitesse sur le calcul de la taille de la chaîne.

Je crois que ce n'est pas commun.
- J'espère jamais qui se passe, parce que le C++ chaînes de prétendre être en mesure de stocker tous les caractères, y compris éventuellement les caractères null.
- D'accord avec A. Rex. taille() doit être O(1), c'est à dire stockées de toute façon.
- A. Rex, si vous utilisez l' =="c chaîne de style", il s'arrête la comparaison à la première \0 . donc l'optimisation serait tout à fait valable actuellement.
- En raison de A. Rex point de vérification pour NUL ne peut être fait sur le const char* argument, vous feriez toujours besoin de vérifier la chaîne elle-même était vide, donc vous êtes forcément l'ajout de travaux sur un seul test à vide.
InformationsquelleAutor Jesse Dearing
1

Normalement, oui.

Mais si quelqu'un décide de redéfinir un opérateur, alors tous les paris sont éteints:
```
bool operator == (const std::string& a, const char b[])
{
    return a != b; //paging www.thedailywtf.com
}
```
- Quelqu'un pourrait facilement remplacer le vide() ... ou même tout le reste de l'ensemble de la STL ...
- en fait, si cet opérateur serait défini à l'échelle mondiale, il serait beaucoup plus facile que de changer l'ensemble de la STL. Je ne sais pas si il l'emporterait sur l'opérateur défini sur le std::string objet, dans ce cas, cependant...
- Ouais, mon point était que le C++ permet de tirer l'ensemble de votre pied par la redéfinition des opérateurs de mal, afin de répondre à des questions comme ci-dessus va inévitablement s'appuyer sur des mises en garde.
- Je suis en train de donner à ceci un +1 (en partie pour la mention thedailywtf.com!). J'ai même vu quelqu'un de la définition d'un opérateur< pour un type de priorité en termes d'opérateur>
InformationsquelleAutor John Carter
0

Oui c'est équivalent, mais permet le code de base pour changer la mise en œuvre de ce vide() signifie, en réalité, selon les OS/Hardware/quoi que ce soit et de ne pas nuire à votre code. Il est similaire à la pratique en Java et .NET

InformationsquelleAutor Ray Booysen

Vous devez vous connecter pour publier un commentaire.

Réponse

Discussion