C++ unsigned char array length

Question

I have in my C++ program unsigned char array of hex values:

unsigned char buff[] = {0x03, 0x35, 0x6B};

And I would like to calculate the size of this array so that I can send it on UART port linux using this function:

if ((count = write(file,buff,length))<0)
{
    perror("FAIL to write on exit\n"); 
}

as I can see the length is int number, and buff is an array which can change size during program execution. can anyone help me how to write it. Thanks

Answer 1

You can do this with an array:

size_t size = sizeof array;

with your example that give:

ssize_t count = write(file, buff, sizeof buff);
if (count < 0 || (size_t)count != sizeof buff) {
  perror("FAIL to write on exit\n");
}

Note: I use C semantic because write is from lib C.

---

In C++, you can use template to be sure that you use sizeof with an array.

template<typename T, size_t s>
size_t array_sizeof(T (&array)[s]) {
    return sizeof array;
}

with your example that give:

ssize_t count = write(file, buff, array_sizeof(buff));
if (count < 0 || static_cast<size_t>(count) != array_sizeof(buff)) {
  perror("FAIL to write on exit\n");
}

Answer 2

And I would like to calculate the size of this array so that I can send it on UART port linux using this function...

You need a COUNTOF macro or function. They can be tricky to get right in all cases. For example, the accepted answer shown below will silently fail when working with pointers:

size_t size = sizeof array;
size_t number_element = sizeof array / sizeof *array;

Microsoft Visual Studio 2005 has a built-in macro or template class called _countof. It handles all cases properly. Also see the _countof Macro documentation on MSDN.

On non-Microsoft systems, I believe you can use something like the following. It will handle pointers properly (from making COUNTOF suck less):

template <typename T, size_t N>
char (&ArraySizeHelper( T (&arr)[N] ))[N];
#define COUNTOF(arr) ( sizeof(ArraySizeHelper(arr)) )

void foo(int primes[]) {
   // compiler error: primes is not an array
   std::cout << COUNTOF(primes) << std::endl;
}

Another good reference is Better array 'countof' implementation with C++ 11. It discusses the ways to do things incorrectly, and how to do things correctly under different compilers, like Clang, ICC, GCC and MSVC. It include the Visual Studio trick.

---

buff is an array which can change size during program execution

As long as you have the data at compile time, the countof macro or function should work. If you are building data on the fly, then it probably won't work.

---

This is closely related: Common array length macro for C?. It may even be a duplicate.

Answer 3

As one of the options to get the number of elements you can use such template:

template<typename T, size_t s>
size_t arrSize(T(&)[s])
{
    return s;
}

And afterwards call:

auto length = arrSize(buff);

This could be used across the code for various array types.

In case by array size you mean its total byte size you can just use the sizeof(buff). Or as others suggested you can use std::array, std::vector or any other container instead and write a helper like this:

template<typename T>
size_t byteSize(const T& data)
{
    typename T::value_type type;
    return data.size() * sizeof(type);
}

Then to acquire the actual byte size of the data you can simply call:

std::vector<unsigned char> buff{0x03, 0x35, 0x6B};
auto bSize = byteSize(buff);

Answer 4

If you are using C++11 you might think of switching to

#include <array>
std::array<char, 3> buff{ {0x03, 0x35, 0x6B} }; 

That offers an interface like std::vector (including size & data) for fixed arrays. Using array might prevent some usual errors and offer some functionality covered by <algorithm>.

The call to write will then be:

write(file,buff.data(),buf.size())