Determining if a C-style string is alphabetic

Question

I'm looking for the fastest way to determine if a C-style string contains only alphabetic characters.

For this question, there are a few assumptions:

1. strlen(c) > 0
2. Strings are null-terminated
3. Continuous character encoding from a-z and A-Z is not guaranteed, but likely.
4. The string is not a null pointer, nor is the pointer its "default value".

#include <stdbool.h>
#include <ctype.h>

bool stralpha(const char *c)
{
    bool alphabetic = true;

    while(*c)
        alphabetic &= !!isalpha(*c++);

    return alphabetic;
}

/* so gcc does not complain */
int main(void){}

To be clear: I know that any performance difference in such a function will be minimal at best. This is just for fun.

In my case, I was having issues with the function returning false even when c was purely alphabetic. That is why I use double negation !! on isalpha(), because it is not guaranteed to return consistently 0 or 1 per the standard.

Answer 1

The main problem with your code (in terms of performance) is that it processes every character in the string regardless. It's probably better to actually exit early if you find a non-alpha character, with something like:

bool isStrAlpha (const char *chPtr) {
    // if (*chPtr == '\0') return false;
    while (*chPtr != '\0')
        if (! isalpha (*chPtr++))
            return false;
    return true;
}

And just a couple of extra notes:

• This code works fine even for zero-length strings, assuming the intent is to ensure whatever characters are in the string are all alpha. In other words, it considers an empty string valid because it contains no non-alpha characters. If you want to ensure the string has to have at least one alpha, just reinstate the commented-out line at the start of the function.

• Your second assumption is superfluous. A series of characters that are not terminated with \0 is not actually a string in C.

• Whether alpha characters are likely to be consecutive is not relevant in my opinion, I usually prefer correct, portable code over speed. But, in any case, you can be reasonably certain that the people who created your implementation will have optimised the wazoo out of the character classification stuff.

Answer 2

First and foremost, I should point out that if you're doing performance work, you should profile the code to see where the slowdown is. That will allow you to determine objectively whether changes you make are actually helping or not.

You have 2 negations on your call to isalpha(). If you remove them both, you'll get the same result, but faster. I had originally thought that the double negation of isalpha() was pointless, but others have pointed out that it's needed because of quirks in the C language. Given that, and given that I don't recall ever running into this in the wild, I'd recommend reformulating it. There are a few options:

1. Get rid of the &= as mentioned below.
2. Write a function that returns an actual bool value so you don't have to worry about this particular quirk.
3. Change the local call site to calculate a bool by doing something like alphabetic &= (isalpha(*c++) != 0);
4. At the very least, comment on why you need the !! in the first place since it's not immediately obvious.

You could exit the loop early at the first non-alphabetic character. So something like:

while ((*c) && (alphabetic))
{
    alphabetic &= isalpha(*c++);
}

A local in-line implementation of isalpha() is likely to be faster than a system library call. Of course, that makes maintenance harder because you have to have a different version for each encoding, given the possibility of non-contiguous a-z characters. A simple way, if you can guarantee 8-bit characters, is to have a 256 element lookup-table where each element is true or false. You could automatically build it by doing something like:

bool alphaTable[256];
for (int nextChar = 0; nextChar < 256; nextChar++)
{
    alphaTable[nextChar] = isalpha(nextChar);
}

Then your loop becomes:

bool alphabetic = true;
while((*c) && (alphabetic))
{
    alphabetic = alphaTable[*c++];
}

You can get rid of the &= because whenever it becomes false, 1) we're done, and 2) all future values will be false.

This could be made even faster by using SIMD instructions. The details would vary depending on the architecture, so again, more maintenance. If you have a very large number of strings to calculate this on at one time, you could also perform multiple simultaneous calculations by running the function on multiple cores at the same time.

Answer 3

Not much to review except a typo (it should be <ctype.h>). As noted in the other answer, !! is of a dubious value.

As for fun, a true nostalgic seventies loop would look like

    while (isalpha(*c++)) {
        ;
    }
    return !c[-1];

Answer 4

The truly fastest way is some manner of look-up table, as demonstrated in another answer. Such a table could even be generated at compile time:

const bool is_alpha [256] =
{
  ['A'] = true,
  ['B'] = true,
  ...
  ['Z'] = true,
  ['a'] = true,
  ...
};

Elements that aren't set to true are guaranteed to be default initialized to 0 = false.

---

That being said, here is my code review:

Bugs

• bool alphabetic = true; means that your function will return true if the first element of the array is \0.

• You don't stop once you find an invalid character, so the whole function is needlessly slow.

Coding style

• The !! is fine. The other reviews fail to grasp that the C standard only guarantees: (C11 7.4.1)

  The functions in this subclause return nonzero (true) if and only if the value of the argument c conforms to that in the description of the function.

  This text has remained unchanged since C90, as in before C had a boolean type. So it does not mean that the function necessarily returns boolean true, but rather that it returns anything non-zero.

  However, the code would be more readable if you write is_alpha(...) != false. The use of !! is often criticised as obfuscation.

• The use of ++ (pre or postfix) mixed with other operators in the same expression is widely recognized as bad practice. There are many dangers with this, both operator precedence bugs and risk of invoking poorly-defined behavior. In addition, it makes the code hard to read.

  Suppose for example that someone comes in and maintains the code, want to allow spaces, is aware that the is... functions return anything non-zero, and therefore writes something like !!(isalpha(*c++) | isspace(*c)). Boom, severe bug, undefined behavior.

  Therefore, never write things such as *c++ even though this happen to be a very commonly used C trick. There is no benefit what-so-ever of mixing ++ with other operators, only dangers.

• The use of while(*c) is a debated coding style. As such, it is a bit subjective - some think this style is fine as it is "traditional C". Others, like the MISRA-C coding standard (and me) prefer while(*c != '\0') as this is more self-documenting, improves possibilities of static code analysis and prevents mix-ups with c != NULL, which of course means something else entirely.

• Always use compound statements { } after all control and loop expressions, with no exceptions. To skip this when there's just one line of code trailing is bad and dangerous practice. Such coding style caused the most expensive bug ever written in the history of programming, after which there are no arguments left that justifies the style.

---

A fixed version:

bool stralpha(const char *c)
{
  if(*c == '\0')
  {
    return false;
  }

  while(*c != '\0' && isalpha(*c))
  {
    c++;
  }

  return *c == '\0';
}

Answer 5

A few years late to this party.

---

Take advantage that isalpha('\0') is false

No need to test twice in the loop for both ch != 0 and isalpha(ch). This can readily make a faster loop.

@user7649 suggestion to stop once a non-alpha is found is a good idea.

Avoid undefined behavior (UB)

Since char may be signed, calling isalpha(ch) is undefined behavior (UB) when ch < 0 && ch != EOF. is...(ch) are specified to work when ch is in the range [0...UCHAR_MAX] and EOF. C2X draft § 7.4 1

In all cases the argument is an int, the value of which shall be representable as an unsigned char or shall equal the value of the macro EOF. If the argument has any other value, the behavior is undefined.

<string.h> functions operate as unsigned char *

For all functions in this subclause, each character shall be interpreted as if it had the type unsigned char C2X draft § 7.26.1 4

OP's code should function the same.

Imprecise requirement

"Strings are null-terminated" and "The string is not a null pointer" are not needed per the C library string definition.

A string is a contiguous sequence of characters terminated by and including the first null character. § 7.1.1 1

Maybe better to say: "The parameter c points to a C string."

Be aware of locale issues

In the default locale there are 26 + 26 characters that return isalpha() as non-zero (true). Other locales may have more. Depending on coding goals this is an advantage or not.

If code goal is only the common A-Z, a-z regardless of locale, consider making your own table.

static const unsigned char is_az[UCHAR_MAX + 1] = { //
  ['A'] = 1, ['B'] = 1, /* 23 more */, ['Z'] = 1,
  ['a'] = 1, ['b'] = 1, /* 23 more */, ['z'] = 1,
};  // The rest will be 0.

unsigned char [] array used here as it is more compact that bool [] when bool is size > 1. We could use bits of the array, but let us leave that for later.

---

Sample alternative:

#include <stdbool.h>
#include <ctype.h>

bool stralpha_alt(const char *c) {
  const unsigned char *uc = (const unsigned char *) c;

  while (isalpha(*uc)) {
    uc++;
  }

  // Let us not assume strlen(c) > 0

  // If stralpha_alt("") is to return true, then
  return *uc == '\0';  // True if looping stopped due to null character.
  
  // If stralpha_alt("") is to return false, then
  return *uc == '\0' && uc != c;
}

Answer 6

The ++ operator, when used as an expression, is error-prone in case someone later adds or removes some lines. Just use a regular loop, the optimizer will compile most of the answers given here to the same code anyway:

bool isalpha_str(char const* s)
{
    for(; *s; ++s)
    {
        if(!isalpha(*s))
        {
            return false;
        }
    }
    return true;
}

Answer 7

If a char is 8 bytes and a short is 16 bytes (you'd have to enforce this beforehand) you could do some loop unrolling and test up to two characters at once for some modest improvements. I tested this out with a 27 characters string (with the non-alpha at the end so as not to exploit the original code's lack of short circuiting) and tested it against the basic 256-entry lookup table version. The unrolled version was about 25% faster on my machine using gcc and -O3 for both.

bool alphaTable16[65536];

void init16 ()
{
    for (int i=0; i<256; ++i)
    {
        for (int j=0; j<256; ++j)
        {
            char k[2]={i,j};
            alphaTable16[*(unsigned short *)k]=isalpha(k[0]) && isalpha(k[1]);
        }
    }
    for (int j=0; j<256; ++j)
    {
        alphaTable16[j]=isalpha(j);
    }
}

bool stralpha2 (const char *c)
{
    while (true)
    {
        const char *d=c;
        if (*c++==0) /* test no characters */
            return true;
        if (*c++==0) /* test one character */
            return alphaTable16[*d];
        /* test two characters */
        if (!alphaTable16[*(unsigned short *)d]) return false;
    }
}

Answer 8

The above answers using the is_alpha array are expensive in terms of memory.

you can use:

bool is_alpha(char c) {
     //A-Z
     if( (c>=65) && (c<=90) )
         return true;
     if( (c>=97) && (c<=122) )
         return true;
     return false;
}

all the conditions can be in one line, it is for clarity.