Defining Array C/C++

Question

What is the difference between this two array definitions and which one is more correct and why?

#include <stdio.h>
#define SIZE 20

int main() {

    // definition method 1:
    int a[SIZE];
    // end definition method 1.

    // defintion method 2:
    int n;
    scanf("%d", &n);
    int b[n];
    // end definition method 2.

    return 0;
}

I know if we read size, variable n, from stdin, it's more correct to define our (block of memory we'll be using) array as a pointer and use stdlib.h and array = malloc(n * sizeof(int)), rather than decalring it as int array[n], but again why?

Answer 1

It's not "more correct" or "less correct". It either is xor isn't correct. In particular, this works in C, but not in C++.

Answer 2

You are declaring dynamic arrays. Better way to declare Dynamic arrays as

int *arr;  // int * type is just for simplicity
arr = malloc(n*sizeof(int*));  

this is because variable length arrays are only allowed in C99 and you can't use this in c89/90.

Answer 3

In (pre-C99) C and C++, all types are statically sized. This means that arrays must be declared with a size that is both constant and known to the compiler.

Now, many C++ compilers offer dynamically sized arrays as a nonstandard extension, and C99 explicitly permits them. So int b[n] will most likely work if you try it. But in some cases, it will not, and the compiler is not wrong in those cases.

Answer 4

If you know SIZE at compile-time:

int ar[SIZE];

If you don't:

std::vector<int> ar;

I don't want to see malloc anywhere in your C++ code. However, you are fundamentally correct and for C that's just what you'd do:

int* ptr = malloc(sizeof(int) * SIZE);
/* ... */
free(ptr);

Variable-length arrays are a GCC extension that allow you to do:

int ar[n];

but I've had issues where VLAs were disabled but GCC didn't successfully detect that I was trying to use them. Chaos ensues. Just avoid it.

Answer 5

I think that metod1 could be little bit faster, but both of them are correct in C.

In C++ first will work, but if you want to use a second you should use:

 int size = 5;
 int * array = new int[size];

and remember to delete it:

 delete [] array;

Answer 6

I think it gives you more option to use while coding.

If you use malloc or other dynamic allocation to get a pointer. You will use like p+n..., but if you use array, you could use array[n]. Also, while define pointer, you need to free it; but array does not need to free.

And in C++, we could define user-defined class to do such things, and in STL, there is std::vector which do the array-things, and much more.

Answer 7

Both are correct. the declaration you use depends on your code.

The first declaration i.e. int a[size]; creates an array with a fixed size of 20 elements. It is helpful when you know the exact size of the array that will be used in the code. for example, you are generating table of a number n up till its 20th multiple.

The second declaration allows you to make an array of the size that you desire. It is helpful when you will need an array of different sizes, each time the code is executed for example, you want to generate the fibonacci series till n. In that case, the size of the array must be n for each value of n. So say you have n = 5, in this case int a [20] will waste memory because only the first five slots will be used for the fibonacci series and the rest will be empty. Similarly if n = 25 then your array int a[20] will become too small.

Answer 8

Q1 : First definition is the static array declaration. Perfectly correct. It is when you have the size known, so no comparison with VLA or malloc().

Q2 : Which is better when taking size as an input from the user : VLA or malloc .

VLA : They are limited by the environment's bounds on the size of automatic allocation. And automatic variables are usually allocated on the stack which is relatively
small.The limitation is platform specific.Also, this is in c99 and above only.Some ease of use while declaring multidimensional arrays is obtained by VLA.

Malloc : Allocates from the heap.So, for large size is definitely better.For, multidimensional arrays pointers are involved so a bit complex implementataion.

Check http://bytes.com/topic/c/answers/578354-vla-feature-c99-vs-malloc

Answer 9

The difference if you define array using malloc is that, you can pass the size of array dynamically i.e at run time. You input a value your program has during run time. One more difference is that arrays created using malloc are allocated space on heap. So they are preserved across function calls unlike static arrays.

example-

       #include<stdio.h>
       #include<stdlib.h>
       int main()
       {
           int n;
           int *a;
           scanf("%d",&n);
           a=(int *)malloc(n*sizeof(int));
           return 0;
       }