How to get number of elements in the array of pointers?

Don't use raw arrays. Use a standard container like std::vector or std::array. Both of these have a .size() member, and allow the range-based for syntax:

    for (mystruct* p : m_arr)

If you need C compatability, they both offer a data() member function which returns a pointer to the first element in the underlying array. (In your case, that will be a mystruct **)

Edit: A raw array also supports the range-based for syntax - but only if the visible declaration includes the number of elements (so my_struct* m_arr[2]; is fine, but my_struct* m_arr[] would not work). It is impossible to declare a std::array without defining the size too. Other containers (like std::vector) don't include the size in the declaration.

The usual way of doing this is:

size_t sizeOfArray = sizeof(m_arr)/sizeof(m_arr[0]);

About size_t from wiki:

size_t is an unsigned integer type used to represent the size of any object (including arrays) in the particular implementation. The sizeof operator yields a value of the type size_t. The maximum size of size_t is provided via SIZE_MAX, a macro constant which is defined in the header (cstdint header in C++). size_t is guaranteed to be at least 16 bits wide.

If this is a header file included by all other source code files using m_arr you can use sizeof(m_arr)/sizeof(m_arr[0]) to obtain the number of elements in the array. But this is really dangerous. If at some point the pointer m_arr enters a function as a parameter the scope of the function will not return 2 at sizeof(m_arr) but the number of bytes which the pointer takes in the memory which probably is 8.

So if you want to stick to plain C then you have to pass the number of elements in a separate variable. But if you can use C++ there is a variety of better, safer and even faster solutions.

You can always do such memory arithmetics:

size_t arraySize = sizeof(m_arr) / sizeof(m_arr[0]);

But if you don't have a reason like in When would you use an array rather than a vector/string?:

Then you should use a std::array<mystruct*, 2> m_arr;, the size of which you can access through m_arr.size(), and the address of the underlying native array you get with m_arr.data().

In C++17 you can #include <iterator> and use std::size(m_arr).

Assuming that you have your array as the following:

char *array[3];  

Add an extra item to the array, which is considered to serve as an array terminator.

char *array[3]={"First element","Second element",""};

The rest of it depends on your own coding style, you can check for the terminator and count the number of elements except the terminating string.

Yes, use std::vector, but if you must...

this works for c++11 or greater:

template <typename T, std::size_t N>
constexpr std::size_t sizeofArray(T(&)[N]) {
    return N;
}

Saw this recently in a video about 7 Features of C++ You Can Adopt Today