How to compare ends of strings in C?

Question

I want to make sure my string ends with ".foo". I am using C, a language I am not totally familiar with. The best way I have found to do it is below. Any C gurus want to make sure I'm doing this elegantly and wisely?

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

Answer 1

The strlen(".foo")s are not required. If you really wanted to have it flexible you could use sizeof ".foo" - 1 -- a compile time constant.

Also, a null string check would be good.

Answer 2

I don't have access to a compiler right now, so could someone tell me if this works?

#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;
}

Anyway, be sure to qualify the parameter as const, it tells everyone (including the compiler) that you don't intend to modify the string.

Answer 3

Don't call strlen more than once per string.

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"); }

EDIT: added NULL check for the pedantic. For the ultra pedantic, debate whether it should return non-zero if both str and suffix are both NULL.

Answer 4

I'd suggest the best way of doing it is to reverse the string then compare the first n characters.

There's any number of examples of string reversing functions out there (even Joel cites it as a standard interview question) so just implement one of those then step though the reversed strings to compare.

EDIT in response to downvotes. OK yes, this approach does require additional CPU or memory to implement, but the questioner does not indicate any such constraints and he explicitly asked for an elegant solution. Reversing the strings then comparing from the front is far more elegant than messing around finding the end of the strings and working backwards. And it's a lot easier for the next programmer along to grasp and maintain too.

Answer 5

You should try to avoid using strlen() multiple times for values you already know, since it's a runtime function. A #define would work here just fine. Also, doing strlen(str) multiple times is a waste: store the length in a variable so that you don't waste cycles with multiple passes through the string.

The revamped code:

#define FOO_FILE_EXTENSION_LENGTH 5 /* length includes the null terminator */

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

Answer 6

You can also generalize like this:

int endsWith(const char* text, const char* extn)
{
    int result = 1;
    int len = strlen(text);
    int exprLen = strlen(extn);
    int index = len-exprLen;
    int count = 0;

    if(len > exprLen)
    {
     for( ; count  < exprLen; ++count)
     {
      if(text[index + count] != extn[count])
      {
       result = 0;
       break;
      }

     }
    }
    else
    {
     result = 0;
    }
    return result;
}

Answer 7

Tested code, includes the 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;
}

Answer 8

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

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

  return( -1 );
}

Will return 0 if ending with ".foo".

Answer 9

Maybe...

bool endswith (const char* str, const char* tail)
{
  const char* foo = strrstr (str, tail);
  if (foo)
  {
     const int strlength = strlen (str);
     const int taillength = strlen (tail);
     return foo == (str + strlength - taillength);
  }
  return false;
}

endswith (str, ".foo");

By the way, the solution in the original question looks fine other than the repeated strlen calls.

Answer 10

If there's always something beyond the dot, we could indulge in some pointer arithmetic:

int EndsWithFoo (char *str)
{
   int iRetVal = 0;
   char * pchDot = strrchr (str, '.');

   if (pchDot)
   {
      if (strcmp (pchDot+1, "foo") == 0)
      {
         iRetVal = 1;
      }
   }
   return iRetVal;
}

Of course you would probably want to add a little strlen there to check there is something beyond the dot :-)

NB - I didn't run this to check it, but it looks OK to me.

Answer 11

If you can change the signature of your function, then try changing it to

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

This will result in a safer, more reusable and more efficient code:

1. The added const qualifiers will make sure you don't mistakenly alter the input strings. This function is a predicate, so I assume it is never meant to have side-effects.
2. The suffix to compare against is passed in as a parameter, so you can save this function for later reuse with other suffixes.
3. This signature will give you the opportunity to pass the lengths of the strings in if you already know them. We call this dynamic programming.

We can define the function like so:

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;
}

The obvious counter-argument for the extra parameters is that they imply more noise in the code, or a less expressive code.