How to count the total number of valid pointer elements in a C++ template function?

Question

I recently started learning C++ after significant experience in C# and Python.

I'm attempting to create a function template that accepts a pointer parameter, then iterates through its values until the next pointer element is no longer valid. Ideally, I would like the function to accept one generic pointer parameter. It's important to mention that I will not be able to utilize the underlying array directly to calculate its size.

I was able to implement the same concept for a pointer of pointers, which I've included below:

template<class T>
inline constexpr size_t len(const T *pptr[])
{
    if (pptr == nullptr) { return (const size_t)size_t(); }
    const T **begptr = &pptr[0];

    while (*pptr != nullptr)
    {
        pptr++;
    }
    return (const size_t)(pptr - begptr);
}

The problem with trying to implement the same concept for a normal pointer (int *, char *, etc.) is that I don't know how to conditionally break the loop once the counter is no longer valid. I was hoping that I would be able to check if the pointer address is valid, then break accordingly so the final count is accurate.

The pseudo code I have so far for my desired function is included below:

template<class T>
inline constexpr size_t len(const T *ptr)
{
    if (ptr == nullptr) { return (const size_t)size_t(); }
    const T *begptr = &ptr[0];

    while (/*Pointer is valid*/)
    {
        ptr++;
    }
    return (const size_t)(ptr - begptr);
}

So is it possible for me to count the number of valid elements accurately with a loop? I'm open to using a different approach, I really just want some kind of template function that accepts a generic pointer and counts the number of elements accurately.

Thank you all in advance for your time and help, I really appreciate it.

Answer 1

What you are attempting to do with your len() function looking for a nullptr element is only possible with a null-terminated array of pointers, eg:

int* arr[3];
arr[0] = ... some pointer ...;
arr[1] = ... some pointer ...;
arr[2] = nullptr;

size_t arr_len = len(arr); // returns 3

Fail to include that terminating nullptr in the array and your function's loop will end up going into surrounding memory, causing undefined behavior:

int* arr[3];
arr[0] = ... some pointer ...;
arr[1] = ... some pointer ...;
arr[2] = ... some pointer ...; // <-- not nullptr!

size_t arr_len = len(arr); // undefined behavior!

However, your len() function as-is cannot do the same thing with an array of non-pointers, eg:

int arr[3];
arr[0] = ... some value ...;
arr[1] = ... some value ...;
arr[2] = ... some value ...; // <-- can't assign nullptr here!

size_t arr_len = len(arr); // DOES NOT WORK

You can't compare non-pointers to nullptr, but you can compare them to whatever T default-initializes to. So, you will have to re-write the function. You can either pass in the allocated array length as a second parameter, eg:

template<class T>
inline constexpr size_t len(const T pptr[], size_t nump)
{
    if (!pptr) return 0;

    const T *begptr = pptr;

    while ((nump > 0) && (*pptr != T{}))
    {
        ++pptr;
        --nump;
    }

    return (pptr - begptr);
}

int arr[5];
arr[0] = ... some value ...;
arr[1] = ... some value ...;
arr[2] = 0;
arr[3] = ...;
arr[4] = ...;

size_t arr_len = len(arr, 5); // returns 3

Or, you can take in the array by reference instead of by pointer, so you don't lose its size information, eg:

template<class T, size_t N>
inline constexpr size_t len(const T (&pptr)[N])
{
    const T *begptr = &pptr[0];

    for(size_t i = 0; i < N; ++i)
    {
        if (*pptr == T{}) break;
        ++pptr;
    }

    return (pptr - begptr);
}

int arr[5];
arr[0] = ... some value ...;
arr[1] = ... some value ...;
arr[2] = 0;
arr[3] = ...;
arr[4] = ...;

size_t arr_len = len(arr); // returns 3

Answer 2

template<class T, size_t N>
constexpr size_t size(const T(&)[N])
{
    return N;
}

template<class T>
constexpr size_t len(const T& a)
{
    return std::distance(std::begin(a), 
                         std::find(std::begin(a), std::end(a), 
                                   nullptr));
}

https://godbolt.org/z/r7MhT4