Die Verwendung der Gleichheits-operator == für den Vergleich von zwei strings auf Gleichheit in C

int main (int argc, **argv)
{
       if (argv[1] == "-hello")
            printf("True\n");
       else
            printf("False\n");
}

# ./myProg -Hallo 
False

Warum? Ich merke strcmp(argv[1], "-hello") == 0 gibt true zurück,... aber warum kann ich nicht mit dem Gleichheits-operator vergleicht zwei C-strings?

Da Sie darauf Bestand, die Frage ist eine C-Frage, ich habe die Stelle der C++ - code mit C-code. Wenn du unbedingt auf std::cout ich bestehen Sie auf einen C++ - tag.
Sicherlich diese Frage ist ein exaktes Duplikat.

InformationsquelleAutor Carlo del Mundo | 2010-10-14

17

Weil argv[1] (zum Beispiel), ist eigentlich ein Zeiger auf die Zeichenfolge. So alle Sie tun, ist der Vergleich von Zeigern.

InformationsquelleAutor Oliver Charlesworth
12

Kann man nicht vergleichen strings in C mit ==,, weil die C-compiler nicht wirklich eine Ahnung über die Saiten über ein string-literal.

Der compiler bei einem Vergleich mit einem char* auf beiden Seiten, so ist es nicht ein Zeiger-Vergleich (vergleicht die gespeicherten Adressen in den Zeigern)

InformationsquelleAutor Bart van Ingen Schenau
12

In C, da in den meisten Kontexten, ein array "zerfällt zu einem Zeiger auf sein erstes element".

Wenn du also das array "foobar" und verwenden Sie es in den meisten Kontexten, es zerfällt in einen pointer:
```
if (name == "foobar") /* ... */; /* comparing name with a pointer */
```
Was Sie wollen, es zu vergleichen, die Inhalt des Arrays mit etwas. Sie können dies manuell tun
```
if ('p' == *("foobar")) /* ... */; /* false: 'p' != 'f' */
if ('m' == *("foobar"+1)) /* ... */; /* false: 'm' != 'o' */
if ('g' == *("foobar"+2)) /* ... */; /* false: 'g' != 'o' */
```
oder automatisch
```
if (strcmp(name, "foobar")) /* name is not "foobar" */;
```
- if(strcmp(name, "foobar")) wird zu false ausgewertet, wenn die strings gleich sind, denn es gibt 0 zurück, in diesem Fall. if (strcmp(name, "foobar") == 0) wäre besser
- Vielen Dank für das heads-up @Overdrivr. Kommentar Hinzugefügt, um den code deutlich zu machen.
InformationsquelleAutor pmg
7

Weil es keine solche Sache wie eine C-Zeichenfolge.

In C ein string ist in der Regel ein array von char ist, oder ein Zeiger auf char (das ist fast das gleiche). Vergleicht man einen Zeiger/array um ein const-array nicht die erwarteten Ergebnisse.

UPDATE: was ich mit "keine C-Zeichenfolge" ist, es gibt keine Strings in C., Was in der Regel bezeichnet als a 'C string' ist die Sprache unabhängig (als "Pascal-string" ist), es ist die Darstellung von Zeichenketten als null-terminierte lineare array von Zeichen.
- Es ist definitiv ein Ding namens C-string. Ich weiß nicht genau, was du meinst. Vielleicht, dass "Es gibt keine C-string-Typ in der C-Sprache"?
- Das ist nur missbrauchen den Begriff. Was dort beschrieben wird, einen null-terminierten string, der im Gegensatz zu einem "Pascal-String", das die Größe des ersten byte.
- Nun, der Programmiersprache C (als die Vanille C++ ohne STL) nicht in einen string-Typ. Es ist eine compiler-Funktion, die automatisch konvertiert text zwischen doppelten Anführungszeichen "..." auf ein konstantes char-array (das ist null-terminiert), führt zu diesem sehr häufiger Fehler beim Umgang mit Zeichenketten in C/C++.
- Es gibt auch string-Bibliothek Funktionen, die sich auf null-terminierte arrays von char.
- Mehr richtig, ein string-Wert ist vertreten durch eine Folge von Zeichen gefolgt von einem 0-terminator. Diese Sequenzen werden als arrays gespeichert von char (string Literale sind, werden als arrays von char in C, const char in C++).
InformationsquelleAutor jv42
5

In C, string-Werte (einschließlich string-Literale) dargestellt, die als arrays von char gefolgt von einem 0-terminator, und Sie können nicht die == Betreiber zu vergleichen, array-Inhalt; die Sprache einfach nicht zu definieren, den Betrieb.

Außer, wenn es ist der operand entweder die sizeof oder & Betreiber, oder, wenn es ein string-literal verwendet wird, zu initialisieren ein array in einer Erklärung, die einen Ausdruck vom Typ "N-element-array von T" haben wird, dessen Typ implizit in (Karies) in den Typ "Zeiger auf T", und der Wert des Ausdrucks wird die Adresse des ersten Elements des Arrays.

So, wenn Sie schreiben
```
if (argv[1] == "-hello")
```
der compiler implizit konvertiert den Ausdruck "-hello" vom Typ "7-element-array von char" zu "Zeiger auf char" (argv[1] ist bereits ein Zeiger-Typ), und der Wert des Ausdrucks ist der Adresse der Charakter '-'. Also, was == wind-up-Vergleich sind zwei Zeiger Werte, die (wahrscheinlich) nie gleich sein, da "-hello" und argv[1] (wahrscheinlich) besetzen unterschiedliche Regionen im Speicher.

Deshalb Sie haben die Verwendung von Bibliothek-Funktionen wie strcmp() zum vergleichen von string-Werten.
- In C, string-Werte (einschließlich string-Literale) dargestellt, die als arrays von char was sind einen 0-terminator ...
InformationsquelleAutor John Bode
3

Da C-strings dont als solche existieren. Sie sind char-arrays endet in einem \0.

Den Gleichheitsoperator == testen, dass der Zeiger auf das erste element des array gleich sind. Es wird nicht lexikographisch vergleichen.

Auf der anderen Seite "-hello" == "-hello" kann Rückkehr nicht gleich null, aber das bedeutet nicht, dass die == operator vergleicht lexicographycally. Das ist aufgrund von anderen Tatsachen.

Wenn Sie vergleichen wollen lexicographycally, können Sie immer
```
#define STR_EQ(s1,s2)    \
   strcmp(s1,s2) == 0
```
Lesen schwieriger sehe ich, dass ich Sie getaggt wie c++. So könnte man
```
 std::string arg1 ( argv[1] );

 if (arg1 == "-hello"){
    //yeahh!!!
 }
 else{
    //awwwww
 }
```
- Jemand bearbeitet die tag-zu-C++, was aber falsch ist. Es ist wieder C jetzt
InformationsquelleAutor Tom
2

Strings sind nicht einheimische Arten, in C., Was, die Sie vergleichen in diesem Beispiel sind zwei Zeiger. Ein zu Ihrem ersten argument, und die andere ist eine statische Zeichen-array mit dem Inhalt "-Hallo".

Sie wirklich wollen, zu verwenden strncmp oder etwas ähnliches.

InformationsquelleAutor kanaka
1

Wenn man mit ==, du bist der Vergleich von Zeigern. Das heißt, es wird true zurückgeben, wenn die beiden Operanden beziehen sich auf den selben string im Speicher. Daher ist es ungeeignet für die Verwendung in vergleichen von strings lexikographisch.

InformationsquelleAutor waffle paradox
-1

Da C-strings sind Arrays von Zeichen. Arrays sind einfach Zeiger auf das erste element im array, und wenn Sie vergleichen zwei Zeiger mit == vergleicht es die Speicher-Adresse, auf die Sie verweisen, nicht die Werte, auf die Sie zeigen.
- Arrays werden nicht nur Hinweise, meine Güte.
- Einfache Fehler zu machen, wenn man bedenkt, dass arrays Zerfall in Zeigern auf fast jede Ausrede.
- Thornley: ja, es ist am besten, um die Terminologie zu korrigieren. C ist verwirrend genug, ohne dass die Grundlagen falsch.
- Meine Wortwahl war ein wenig harsch, sorry. Aber trotzdem ist es nicht. Es gibt Zeiten, wenn die Annahme wirklich beißen.
InformationsquelleAutor Anthony

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.