Size of static array

Question

I declare a static char array, then I pass it to a function. How to get the no. of bytes in the array inside the function?

Answer 1

Use a function template instead that has a non-type template parameter:

template <size_t N>
void func(char (&a)[N]) {
    for (int i = 0; i < N; ++i) {
        cout << "a[" << i << "] = " << a[i] << endl;   // Or whatever you want to do
    }
}

To call:

char myArray[500];        // Or "static char myArray[500]", if you want
func(myArray);

A new copy of this function will be instantiated for each distinct size of array that it is called with, so if you call it with many different-sized arrays, you'll get some code bloat. But that's not likely to be the case.

Answer 2

You would have to pass it to the function. You can use sizeof() to get the size of an array.

const char foo[] = "foobar";

void doSomething( char *ptr, int length)
{

}


doSomething(foo, sizeof(foo));

This MSDN page has explains more about sizeof and has a bigger example.

Edit: * see j_random_hacker's answer for an intriguing technique using templates... *

Answer 3

You can also use std::size() from C++17

https://en.cppreference.com/w/cpp/iterator/size

#include <iostream>
#include <vector>
#include <iterator>

int main() 
{
    std::vector<int> v = { 3, 1, 4 };
    std::cout << std::size(v) << '\n'; 

    int a[] = { -5, 10, 15 };
    std::cout << std::size(a) << '\n';
}

For pre c++17 copy sample implementations ;)

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

Answer 4

int array_size = sizeof(Array) / sizeof(Array[0]);

Answer 5

You can't. Arrays in C++ are pointers, and that is all you have: the pointer to the beginning of the array. If it happens to be a string, you can use strlen to measure its length. If its some other known format, you can calculate the length according to that format.

Consider this code:

static char str[] = "hello world";

foo(str);
bar(str);

void foo(char* str)
{
   // length of str is unknown
}

void bar(char str[])
{
  // length of str is still unknown
}

Regardless of if your function parameter is a char[] or a char*, you don't know the size.

I suggest passing the size in as a separate parameter.

Answer 6

No. Don't use arrays. Use a vector instead. These days there is almost no excuse for using arrays because they are unsafe. AFAIK, they are one of the main reasons for software problems because it's so easy to accidently overrun the end of the array.

Using a vector, you don't have to worry any more about buffer overruns. And your function can easily find out the size of the vecor.

#include <vector>
vector<char> myVector;

void DoSomething(vector<char> &v)
{
    int sizeOfVector = v.size();
}

Answer 7

One other option you have is creating a string class that manages the string. I'm sure someone out there has done this already. The most primitive version is a struct with a char * and the buffer length, where you have to manually manage the size whenever it changes. The other end of the spectrum is a fully implemented string class, with operator overloading and manupulation functions.

Then pass this class to your function and it already knows the size. It isn't really any different then passing it as a separate parameter; it simply is an easier way of managing strings if they're all different lengths.