calculating array sizes in C

Question

I have a macro for calculating array sizes in my C code:

#define sizearray(a)  (sizeof(a) / sizeof((a)[0]))

When I test it, it works fine for statically defined arrays, but not so for dynamically defined arrays (see below). Not sure I understand why this is the case. Is there any way of calculating the size of an array allocated on the heap?

/* test sizearray macro */
void testSIZEARRAY(void)
{
    /* test case for statically defined array */
    int a[5] = {0,0,0,0,0};

    assert(sizearray(a) == 5);

    /* test case for dynamically defined array */
    int *b;

    b = calloc(5, sizeof(int));

    assert(sizearray(b) == 5);

    free(b);
}

sizeof is evaluated at compile-time. So, no, thats not possible. — ordag
– ordag, Commented Jan 5, 2012 at 22:26
possible duplicate of How to get the length of a dynamically created array of structs in C? — Sergey Kalinichenko
– Sergey Kalinichenko, Commented Jan 5, 2012 at 22:27
@ordag sizeof is evaluated at compile-time if it can be. It is evaluated at runtime for VLAs. — David Heffernan
– David Heffernan, Commented Jan 5, 2012 at 22:57

Mysticial · Accepted Answer · 2012-01-05 22:37:34Z

5

The answer is no, there is no standard way to get the size of a dynamically allocated array.
For all practical purposes, you have to keep track it yourself.

However, there are some compiler-specific methods that do that:

Windows (Visual Studio): _msize()

GCC: msize() Can't find it in the GCC docs...

edited Jan 5, 2012 at 22:37

answered Jan 5, 2012 at 22:26

Mysticial

473k46 gold badges343 silver badges337 bronze badges

Sign up to request clarification or add additional context in comments.

4 Comments

dbeer Over a year ago

You might say that generally speaking there's no way to calculate the size of a dynamically allocated array, you just have to keep track of it.

AProgrammer Over a year ago

Does it returns the allocated size or the size which was asked?

Mysticial Over a year ago

@AProgrammer Good question. I'm not sure on that and the docs aren't clear on it.

Mysticial Over a year ago

@AProgrammer It looks like it does return the size that was asked. I just tested it with 1 and 63, sizes that would most certainly have been padded up - and it does return 1 and 63.

ouah · Accepted Answer · 2012-01-05 22:32:15Z

4

int *b;
...
assert(sizearray(b) == 5);

A pointer is not an array. b is declared as pointer to int

Here

sizeof b == sizeof (int *)

The sizeof operator applied to an object of a pointer type is the same as the size of the pointer type and is not equivalent to the size of the allocated array.

To know the size of your allocated array object you have to inspect what was allocated. In your example you allocate an object of 5 int, so the size of your array is:

 5 * sizeof (int)

(or equivalent, 5 * sizeof *b)

edited Jan 5, 2012 at 22:32

answered Jan 5, 2012 at 22:26

ouah

147k16 gold badges287 silver badges338 bronze badges

Comments

Seramme · Accepted Answer · 2012-01-05 22:29:09Z

3

There is no way to calculate the size of an array if you only have a pointer to its first element (as you do in the above case with int *b). You need to either store the array size separately and use it together with your pointer, or somehow mark the end of the array. The latter solution is used in character arrays, which are usually null-terminated (have \0 as their last character). In this case, you can calculate the size by looping till you encounter such a termination character.

answered Jan 5, 2012 at 22:29

Seramme

1,3257 silver badges9 bronze badges

Comments

alk · Accepted Answer · 2012-01-06 15:52:21Z

The followng is bad advice, do not do that.

To get the memory allocated by the current glibc's malloc() (et al) you could try the following:

#include <stdlib.h>
#include <stdio.h>

#define GLIB_MSIZE_T size_t /* We need to have a four byte unsigned integer type 
                               here. */

#define GLIB_MSIZE(p) \
        *((GLIB_MSIZE_T*) (((char*) p) - sizeof(GLIB_MSIZE_T)))

int main(int iArgC, char ** ppszArgV)
{
        if (1 >= iArgC)
        {
                fprintf(stderr, "usage: %s <bytes to allocate>\n", ppszArgV[0]);
                return EXIT_FAILURE;
        }

        {
                /* This conversion uing 'atol()' only works up until to a certain size
                   of the integer represented by 'ppszArgV[1]'. */
                size_t size = atol(ppszArgV[1]);

                void * pv = malloc(size);
                if (!pv)
                {
                        fprintf(stderr, "Allocation of %u bytes failed.\n", size);
                        return EXIT_FAILURE;
                }

                printf("Asked for %u bytes, got %u bytes.\n", size, GLIB_MSIZE(pv));
        }

        return EXIT_SUCCESS;
}

Besides the fact one indeed could get the amount of memory allocated, the interesting thing to see when paying with this code is, that in most of the cases more then the size of memory requested is assigned.

Anyhow, the latter makes it unsafe trying to pull information from this on the exact size originally requested.

Collectives™ on Stack Overflow

calculating array sizes in C

4 Answers 4

4 Comments

Comments

Comments

Comments

Your Answer

Linked

Hot Network Questions

Collectives™ on Stack Overflow

4 Answers 4

4 Comments

Comments

Comments

Comments

Your Answer

Sign up or log in

Post as a guest

Linked

Related