C99：strrpbrk 的存在（反向 strpbrk）

Question

I am almost sure there is no reverse strpbrk() in C99. But:

1. Is there a reason for that? I mean, why does strchr() have strrchr() but strpbrk() doesn't hae strrpbrk() ?

2. How do you get the last occurrence in a string of any of the characters in another string?

Answer 1

1. In my opinion, because no one thinks out of the box, stpcpy isn't part of C99 either :(

2. Look at glibc's stpbrk implementation to get an inspiration, it's not that hard

   /* Find the first occurrence in S of any character in ACCEPT. */ char * strpbrk (s, accept) const char *s; const char *accept; { while (*s != '\\0') { const char *a = accept; while (*a != '\\0') if (*a++ == *s) return (char *) s; ++s; } return NULL; }

Answer 2

Note that strpbrk() is NOT optimized if the second string is long and contains duplicates.

One obvious thing to do would be to scan first the second string for a limited length (at most 256 bytes including the null terminator as it typically does not contain duplicates): if this string is found to be longer, it contains duplicate bytes.

During this scan, it can create a bitmap (32 bytes needed if using a packed form: this can easily be allocated as an automatic array on the stack, but access to the bitmap may be longer; if you don't optimize for stack space, you may want to just create an array of 256 booleans stored as one byte for each boolean, this would use 256 bytes on the stack). That array would normally set the boolean at position 0 that will be true if the second string is shorter than 255 bytes as it would be followed by the null terminator. That boolean in the array at position 0 (indicating a long second string) could be kept in a register, as well as the last position still not scanned in the second string (s2+256). Typically this initial step will be short (and its worst case is bound by design).

Now you can scan the first string and perform simple indexing on the scanned byte to see if it is set to true in the array of boolean. Otherwise, check if the long string indicator is set, if not you need to scan further the second string (and continue feeding the array of booleans until you locate the character of the first string or the null terminator, update the last position scanned in that local register).

In most cases, this will optimize a lot because you don't perform two loops (loops are costly because of their conditional jumps needing breach prediction, each string will be scanned (partly) at most once. The only price is the indirection for accessing the array of booleans in the stack, but that array is small enough to fit inside the CPU data cache (so the indirection has a virtual cost of zero).

This works because strpbrk() works on array of char (limited to 256 possible values). The initial scan of the second string will most often be complete and will set the array completely (so its null byte termination will be detected and will set the first boolean to true).

A secondary optimization would be to use the value of this first boolean in the array when it is true (the second string is short) to reduce the second loop so that it will only perform indexing without retesting if it needs to scan the second string further.

A profiler may reveal that you actually don't need to scan first up to 256 bytes in the first loop, and most code will typically use a second string that is at most 16 bytes long. You may even optimize the case where the second string is empty or contains a single character, in which case you won't need to use any array or extra register and you can either return NULL directly (the second string is empty, only a single null byte) or just scan the first string for a single character value or null byte. Which length to use (for the initialization scanning the second string) could be determined on profiling your apps using that function

I bet that 16 would be good enough, you may find that a shorter value of 8 bytes may eventually be a bit better most of the time but at the price of using the complex branch (with the embedded loop conditionally continuing scanning the second string and updating more data in the array of booleans) more often in some cases. Profiling may also help determine if you want a packed array of booleans (stored as single bits instead of full bytes) or an extended array (booleans stored as plain words: this may be architecture-dependent), or if you can use registers instead of an array (for architectures that have many registers).

And as I said, the only cost is stack use (but it can be limited if you pack the array; it could optionally use the heap on some architectures that have very small stacks, but using the heap has a price and generally it uses complex code that could require more heap usage and extra costs for the internal function calls and calls to system's API).

Some extreme optimizations may also use vector instructions. So glibc could still be largely optimized for the implementation of this function.

---

The same initialization could then be used to implement the proposed "reverse" strrpbrk() , that must scan the first string up to its terminating null byte, and keep a local pointer register storing the last position found (instead of stopping on the first occurrence found): for implementing it , you could as well call strpbrk() repeatedly in a loop until it returns NULL.

For that implementation, don't use strrev() for that purpose: reversing the first string first has a cost: it requires at least two loops, the first one to know its effective length, and it requires either extra storage (unbound limitation for the 1st string, so it cannot be allocated on the stack and would use the heap, which is quite costly), or it requires transforming in place before scanning it, then deallocate the extra storage or undo the in-situ transform by reversing it again: this would not work if the first string is shared by competing threads, causing possible security issues.

Answer 3

Because int lastMatchIdx=strlen(haystack)-strpbrk(strrev(haystack),needles) is too easy to write? And has the same complexity (though somewhat less empirical performance)

for(char* h=haystack;(h=strpbrk(h,needles))!=NULL;rightMostMatch=h++); is similarly simple

Answer 4

As for how to make a strrpbrk i suppose best is to repeat strrchr() for each character in second param and keep record of the highest pointer.

Regarding the strpbrk function definition i wish the Standard developers would have been more precise. There should be two variants of this function -- one that searches for one character at a time from param 2 and returns first match found (glibc variant) and one that returns the very first of the possible characters in the string (this MSVC seems to do). But i guess the world wont even be perfect...