How to determine how many elements there are in an array of compound literals in C?

Question

How can I determine how many elements there are in an array of compound literals. I'm using the well known macro sizeof(a)/sizeof(a[0]); but keep getting 1.

#include <stdio.h>
typedef struct {
    int enable;
    const char * const *message;
} table_s;

static const table_s table[] =
{
    { 1, (const char * const []){ "Message 1", "Message 2"   } },
    { 1, (const char * const []){ "Message 1", "Message 2", "Message 3"} }
};

#define NELEMS(x)  (sizeof(x) / sizeof(x[0]))
int main(int argc, char *argv[]) {
    printf("%d\n", NELEMS(table[0].message));
    printf("%d\n", NELEMS(table[1].message));
    return 0;
}

`const char * const *message;` – BLUEPIXY Jun 24 '13 at 15:36 — BLUEPIXY, Jun 24 '13 at 15:36
`x` and `x[0]` are the same thing for arrays – Suvarna Pattayil Jun 24 '13 at 15:37 — Suvarna Pattayil, Jun 24 '13 at 15:37
`sizeof(char**)/sizeof(char*)` – BLUEPIXY Jun 24 '13 at 15:45 — BLUEPIXY, Jun 24 '13 at 15:45

score 1 · Accepted Answer · answered Jun 24 '13 at 15:53

1

sizeof(a)/sizeof(*a) will only work if a is a compile time dynamic size block and is typed as such.

char * messages[] = { "Message 1", "Message 2", "Message 3"};

sizeof(messages)/sizeof(*messages) = sizeof((char *)[3]) / sizeof(char*) = 3

But in your case you are operating on a pointer type

  NELEMS(table[0].message) 
= sizeof(table[0].message) / sizeof(table[0].message[0]) 
= sizeof(const char * const *)/sizeof(const char * const) 
= sizeof(void *) / sizeof(void *) = 1

answered Jun 24 '13 at 15:53

Sergey L.

21,822
5
49
75

See http://stackoverflow.com/questions/16958376/c-realloc-usage/16958626#comment24490649_16958626. It's an interesting comment about pointer size. – Xaqq Jun 25 '13 at 07:18

score 0 · Answer 2 · answered Jun 24 '13 at 15:53

0

You can not do that in C cause of the way a C array works.

let's say you have int a[100];

a is just a pointer to the area of the memory where the elements are put one after the other.

In this example the size on bytes of an int is 4. The size of a pointer to int (int*) is also 4 bytes.

a is a variable which only stores a mem dress like 0x0000866A

and in mem starting at that address you will find:

a[0]_on_first_4_bytes|a[1]_next_4_bytes|a[2]_next_4_bytes concatenated one near the other.

But since the size of (int*) = size of (int) => Size of a = size of a[0] .

Unless you store somewhere the number of elements you can't find it otherwise.

answered Jun 24 '13 at 15:53

Avner Solomon

1,486
11
17

`a` isn't a pointer, it's an array, which decays to a pointer. He is using pointers, though. (the type of `message` is a pointer) – Dan Jun 24 '13 at 16:15
C implements arrays as constant pointer. I was just trying to explain the size to him. `int a[10]` is the same as `int *a; a = malloc(10*sizeof(int);` – Avner Solomon Jun 24 '13 at 16:25
Oh .. and just to be clear. The compilator allocates space for the that array. Either way the literal 'a' is a pointer to a memory zone. You can try a pointer printf on in. and check the memory with your fave mem dump program or something. – Avner Solomon Jun 24 '13 at 16:33

score 0 · Answer 3 · answered Jun 24 '13 at 15:53

The "well known macro" only works with arrays and not with pointers.

What you are doing is taking the size of a pointer to a pointer and dividing it by the size of a pointer. Pointers to data of any type are almost always the same size. This is why you are getting 1 as your result.

How to determine how many elements there are in an array of compound literals in C?

3 Answers3