Basic array usage in C?

Question

Is this how you guys get size of an array in ANSI-C99? Seems kind of, um clunky coming from higher language.

int tests[7];
for (int i=0; i<sizeof(tests)/sizeof(int); i++) {
    tests[i] = rand();
}

Also this Segmentation faults.

int r = 10000000;
printf ("r: %i\n", r);
int tests[r];

run it:

r: 10000000
Segmentation fault

10000000 seg faults, but 1000000 works.

How do I get more info out of this? What should I be checking and how would I debug something like this? Is there a limit on C arrays? What's a segmentation fault?

Answer 1

Getting size of an array in C is easy. This will give you the size of array in bytes.

sizeof(x)

But I guess what you require is number of elements, in that case it would be:

sizeof(x) / sizeof(x[0])

You can write a simple macro for this:

#define NumElements(x)  (sizeof(x) / sizeof(x[0]))

For example:

int a[10];
int size_a = sizeof(a); /* size in bytes */
int numElm = NumElements(a); /* number of elements, here 10 */

Answer 2

Why calculate the size?

Define a constant containing the size and use that when declaring the array. Reference the constant whenever you want the size of the array.

As a primarily C++ programmer, I'll say that historically the constant was often defined as an enum value or a #define. In C, that may be current rather than historic, though - I don't know how current C handles "const".

If you really want to calculate the size, define a macro to do it. There may even be a standard one.

The reason for the segfault is most likely because the array you're trying to declare is about 40 megabytes worth, and is declared as a local variable. Most operating systems limit the size of the stack. Keep your array on the heap or in global memory, and 40 megabytes for one variable will probably be OK for most systems, though some embedded systems may still cry foul. In a language like Java, all objects are on the heap, and only references are kept on the stack. This is a simple and flexible system, but often much less efficient than storing data on the stack (heap allocation overheads, avoidable heap fragmentation, indirect access overheads...).

Answer 3

Traditionally, an array has a static size. So we can do

#define LEN 10
int arr[LEN];

but not

int len;
scanf("%d", &len);
int arr[len]; // bad!

Since we know the size of an array at compile time, getting the size of an array tends to trivial. We don't need sizeof because we can figure out the size by looking at our declaration.

C++ provides heap arrays, as in

int len;
scanf("%d", &len);
int *arr = new int[len];

but since this involves pointers instead of stack arrays, we have to store the size in a variable which we pass around manually.

Answer 4

Arrays in C don't know how big they are, so yes, you have to do the sizeof array / sizeof array[0] trick to get the number of elements in an array.

As for the segfault issue, I'm guessing that you exceeded your stack size by attempting to allocate 10000000 * sizeof int bytes. A rule of thumb is that if you need more than a few hundred bytes, allocate it dynamically using malloc or calloc instead of trying to create a large auto variable:

int r = 10000000;
int *tests = malloc(sizeof *test * r);

Note that you can treat tests as though it were an array type in most circumstances (i.e., you can subscript it, you can pass it to any function that expects an array, etc.), but it is not an array type; it is a pointer type, so the sizeof tests / sizeof tests[0] trick won't work.

Answer 5

Stack Overflow! Try allocating on the heap instead of the stack.

Answer 6

I suspect that it is because of integer overflow. Try printing the value using a printf:

printf("%d", 10000000);

If it prints a negative number - that is the issue.