Wie vergleicht man die Enden von Strings in C?

Question 1

Ich möchte sicherstellen, dass meine Zeichenfolge mit “.foo” endet. Ich benutze C, eine Sprache, mit der ich nicht ganz vertraut bin. Der beste Weg, den ich gefunden habe, ist unten. Irgendwelche C-Gurus wollen sicherstellen, dass ich das elegant und klug mache?

int EndsWithFoo(char *str)
{
    if(strlen(str) >= strlen(".foo"))
    {
        if(!strcmp(str + strlen(str) - strlen(".foo"), ".foo"))
        {
            return 1;
        }
    }
    return 0;
}

Question 2

Rufen Sie strlen nicht mehr als einmal pro String auf.

int EndsWith(const char *str, const char *suffix)
{
    if (!str || !suffix)
        return 0;
    size_t lenstr = strlen(str);
    size_t lensuffix = strlen(suffix);
    if (lensuffix >  lenstr)
        return 0;
    return strncmp(str + lenstr - lensuffix, suffix, lensuffix) == 0;
}

int EndsWithFoo(const char *str) { return EndsWith(str, ".foo"); }

BEARBEITEN: NULL-Prüfung für die Umständlichkeit hinzugefügt. Für die Ultra-Pedantisten, diskutieren Sie, ob es ungleich Null zurückgeben sollte, wenn sowohl str als auch suffix beide NULL sind.

Question 3

int EndsWithFoo( char *string )
{
  string = strrchr(string, '.');

  if( string != NULL )
    return( strcmp(string, ".foo") );

  return( -1 );
}

Gibt 0 zurück, wenn es mit “.foo” endet.

Question 4

Ich habe gerade keinen Zugriff auf einen Compiler, könnte mir also jemand sagen, ob das funktioniert?

#include <stdio.h>
#include <string.h>

int EndsWithFoo(const char* s);

int
main(void)
{
  printf("%d\n", EndsWithFoo("whatever.foo"));

  return 0;
}

int EndsWithFoo(const char* s)
{
  int ret = 0;

  if (s != NULL)
  {
    size_t size = strlen(s);

    if (size >= 4 &&
        s[size-4] == '.' &&
        s[size-3] == 'f' &&
        s[size-2] == 'o' &&
        s[size-1] == 'o')
    {
      ret = 1;
    }
  }

  return ret;
}

Achten Sie auf jeden Fall darauf, den Parameter als zu qualifizieren constteilt es allen (einschließlich dem Compiler) mit, dass Sie nicht beabsichtigen, die Zeichenfolge zu ändern.

Question 5

Hier ist eine allgemeine Lösung, die dieselben Werte wie Pythons str.endswith() zurückgibt, wobei memcmp() verwendet wird. Es ist beabsichtigt, str / suffix nicht auf NULL zu prüfen, andere libc str-Funktionen prüfen ebenfalls nicht auf NULL:

int ends_with(const char *str, const char *suffix) {
  size_t str_len = strlen(str);
  size_t suffix_len = strlen(suffix);

  return (str_len >= suffix_len) &&
         (!memcmp(str + str_len - suffix_len, suffix, suffix_len));
}

Prüfung C:

printf("%i\n", ends_with("", ""));
printf("%i\n", ends_with("", "foo"));
printf("%i\n", ends_with("foo", ""));
printf("%i\n", ends_with("foo", "foo"));
printf("%i\n", ends_with("foo", "foobar"));
printf("%i\n", ends_with("foo", "barfoo"));
printf("%i\n", ends_with("foobar", "foo"));
printf("%i\n", ends_with("barfoo", "foo"));
printf("%i\n", ends_with("foobarfoo", "foo"));

Ergebnis C:

Test-Python:

print("".endswith(""))
print("".endswith("foo"))
print("foo".endswith(""))
print("foo".endswith("foo"))
print("foo".endswith("foobar"))
print("foo".endswith("barfoo"))
print("foobar".endswith("foo"))
print("barfoo".endswith("foo"))
print("foobarfoo".endswith("foo"))

Ergebnis-Python:

True
False
True
True
False
False
False
True
True

Question 6

Wenn Sie die Signatur Ihrer Funktion ändern können, ändern Sie sie in

int EndsWith(char const * str, char const * suffix, int lenstr, int lensuf);

Dies führt zu einem sichereren, wiederverwendbaren und effizienteren Code:

Die hinzugefügten konstanten Qualifizierer stellen sicher, dass Sie die Eingabezeichenfolgen nicht versehentlich ändern. Diese Funktion ist ein Prädikat, daher gehe ich davon aus, dass sie niemals Nebenwirkungen haben soll.

Das zu vergleichende Suffix wird als Parameter übergeben, sodass Sie diese Funktion zur späteren Wiederverwendung mit anderen Suffixen speichern können.
Diese Signatur gibt Ihnen die Möglichkeit, die Längen der Saiten anzugeben, wenn Sie sie bereits kennen. Wir nennen das dynamische Programmierung.

Wir können die Funktion wie folgt definieren:

int EndsWith(char const * str, char const * suffix, int lenstr, int lensuf)
{
    if( ! str && ! suffix ) return 1;
    if( ! str || ! suffix ) return 0;
    if( lenstr < 0 ) lenstr = strlen(str);
    if( lensuf < 0 ) lensuf = strlen(suffix);
    return strcmp(str + lenstr - lensuf, suffix) == 0;
}

Das offensichtliche Gegenargument für die zusätzlichen Parameter ist, dass sie mehr Rauschen im Code oder einen weniger ausdrucksstarken Code implizieren.

Question 7

Das strlen(".foo")s sind nicht erforderlich. Wenn Sie es wirklich flexibel haben wollten, könnten Sie es verwenden sizeof ".foo" - 1 — eine Kompilierzeitkonstante.

Auch eine Null-String-Prüfung wäre gut.

Question 8

Getesteter Code, beinhaltet den Test:

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

int ends_with_foo(const char *str)
{
    char *dot = strrchr(str, '.');

    if (NULL == dot) return 0;
    return strcmp(dot, ".foo") == 0;
}

int main (int argc, const char * argv[]) 
{
    char *test[] = { "something", "anotherthing.foo" };
    int i;

    for (i = 0; i < sizeof(test) / sizeof(char *); i++) {
        printf("'%s' ends %sin '.foo'\n",
               test[i],
               ends_with_foo(test[i]) ? "" : "not ");
    }
    return 0;
}