What is the difference between array and normal data type?

Answer 1

Data typing is static, but weakly enforced

Answer 2

With a normal data type, such as int, you can only store one value. With an array, you can store several values of the same type in contiguous memory, one after the other. So the first major difference is in the amount of memory allocated.

int a; // allocates 4 bytes

int b[2]; // allocates 2 x 4 bytes (8 bytes in total)

The preceding examples assume sizeof(int) is 4 bytes.

The second major difference is in how the memory is accessed. In the preceding examples, you can assign any integer value to the variable a directly, such as:

a = 5;

However you cannot do the same with b. This is because b is actually a reference to the start address of the array.

b = 5; // can't do this!

To assign a value you must dereference b:

*b = 5; // ok

Typically you will use the index operator to achieve the same thing:

b[0] = 5; // zero-based index

The index operator also allows access to any element in the array, not just the first element:

b[1] = 6; // assign to second element

Although the index operator is generally easier for the programmer, this is simply sugar-coating for what is actually going on Behind the Scenes: pointer arithmetic:

int * p = b; // point to the reference

++p; // increment the pointer

*p = 6; // assign the value

Note that ++p does not increment p by 1, it increments p by sizeof(int), because b was declared to be an array of int.

Another difference between an array and a normal data type is that it is impossible to determine how much memory is allocated to the array. It is therefore the programmer's responsibility to ensure he does not write to memory beyond the array, by maintaining the size of the array in a separate variable. This is also the reason why we must pass the size of an array as well as the array itself into external functions.

It should be noted that in C++ we should avoid arrays altogether as they are not part of the object-oriented paradigm; they were simply inherited from C. Instead we should use vectors. A vector is simply a template class that encapsulates and exposes all the functionality of an array, but combines it with common methods and members associated with arrays, including the size of the array. Passing a vector to an external function is therefore much safer than passing an array because the vector knows the size of the array -- we don't have to keep track of it ourselves. We can still use arrays, of course, but vectors are part of the C++ language and they ensure our programs conform to the object-oriented paradigm.