Char size and const void*

Question

I have a question regarding the size of data in a const void*. In the code below, the output of the first printf is 6 while the output of the second printf is 3. Please help, I cannot find where the problem comes from. Thank you in advance

#define TEST "\x00\x01\x02\x03\x04\x05"

#include <stdio.h>

static void function(const void* c);

int main (void) {

    printf("TEST: %d\n",sizeof(TEST) -1);
    function(TEST);

    return 0;
}

static void function(const void* c) {
    printf("TEST: %d\n",sizeof(c) -1);
}

Answer 1

In the first case, sizeof(TEST) is the size of the string literal, which is an array large enough to contain all the characters plus the terminator - in this case, 7 bytes.

In the second case, sizeof(c) is the size of a pointer - 4 bytes, on your 32-bit platform.

In general, there is no way to tell the size of an array given just a pointer to it. If it pointed to a C-style terminated string, you can measure the length with strlen(c). However, in this case, it contains a null character, so there's no way to determine the length.

In C++, you could use a template, rather than sizeof, to get the size of an array:

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

This has the advantage that you'll get a compile-time error, rather than an unexpected runtime result, if you accidentally apply it to a pointer instead of an array.

Answer 2

The sizeof operator return the number of bytes of either a type name or an expression with respect to sizeof(char). Has the following syntax:

sizeof unary-expression 
sizeof ( type-name ) 

If it's a unary-expression and it's a string literal like you sizeof(TEST) it does return the count of bytes in this string, including null-byte-terminattor. But if it's a expression like 2*p which has int resulting type, the expression is evaluated at compile-time (without any side-effect) and the size of resulting-type (int) is returned, as sizeof(int)

Or if it's type-name like in your sizeof(c) it return the platform-independent number of bytes of this type. e.g, sizeof(int) on 32-bit machine is 4 bytes.