C++ Zero time strlen and strnlen.

Zero time strlen and strnlen? I am reasonably sure it is not me who first thought of this, but today, I figured writing a “zero time” strlen() and strnlen() in modern C++ is actually possible and obvious. Not for pointers though.

And not only for string literals this is. Even better, for any kind of native array.

It might be called a “no brainer”. As soon as you figure it out, though.

// g++ prog.cc -Wall -Wextra -std=c++14
#include <cstdlib>
#include <cassert>

namespace dbj {
 
template<typename T, size_t N>
inline constexpr size_t arrnlen(const T(&)[N], const size_t & maxlen) {
    return std::min(N, maxlen) - 1;
}
template<typename T, size_t N>
inline constexpr size_t arrlen(const T(&)[N]) {
    return N - 1;
}
} 
int main()
{
/* declaration of string literals made up
   of four main char types */
char     promptA[]  =  "0123456789";
wchar_t  promptW[]  = L"0123456789";
char16_t prompt16[] = u"0123456789";
char32_t prompt32[] = U"0123456789";

static_assert( dbj::arrnlen(promptA,  BUFSIZ) == 10 );
static_assert( dbj::arrnlen(promptW,  BUFSIZ) == 10 );
static_assert( dbj::arrnlen(prompt16, BUFSIZ) == 10 );
static_assert( dbj::arrnlen(prompt32, BUFSIZ) == 10 );
}

And yes, we shall call it arrnlen and arrlen, too.

Much better vs ages-old  countof macro lying around.

#define countof(arr) sizeof(arr) / sizeof(arr[0])

Not very good, as noted numerous times:

    • Because macros carry no type, the implementation is not robust and bad usage won’t be detected at compilation time.
    • Macros can’t be overloaded which would be useful for containers.
    • Just like any macro, there are potential namespace collision issues.

So little C++ so much good!

The savings?

What are then the real-time savings of using this? Yes, it is quite hard to compute real-time savings.

It may be hard but it is obvious there must be a time-saving. It depends on the compiler on the OS and on the number of native char arrays aka “string literals” your application processes.

The performance advantage vs. standard  char * based strlen and strnlen must be obvious, in some serious testing apps, someone has written to prove exactly “how much faster” is this.