CODEWITHSUNDEEP
c++arraysstdvector
Raffaele Rossi
Raffaele Rossi

Reputation: 3127

Dynamic and static array

I am studying C++ reading Stroustrup's book that in my opinion is not very clear in this topic (arrays). From what I have understood C++ has (like Delphi) two kind of arrays:

Static arrays that are declared like 

int test[3] = {10,487,-22};

Dynamic arrays that are called vectors

std::vector<int> a;

a.push_back(10);
a.push_back(487);
a.push_back(-22);

I have already seen answers about this (and there were tons of lines and concepts inside) but they didn't clarify me the concept.

From what I have understood vectors consume more memory but they can change their size (dynamically, in fact). Arrays instead have a fixed size that is given at compile time.

In the chapter Stroustrup said that vectors are safe while arrays aren't, whithout explaining the reason. I trust him indeed, but why? Is the reason safety related to the location of the memory? (heap/stack)

I would like to know why I am using vectors if they are safe.

Upvotes: 1

Views: 193

Answers (3)

Connor Schwinghammer
Connor Schwinghammer

Reputation: 186

The reason arrays are unsafe is because of memory leaks.

If you declare a dynamic array

int * arr = new int[size]

and you don't do delete [] arr, then the memory remains uncleared and this is known as a memory leak. It should be noted, ANY time you use the word new in C++, there must be a delete somewhere in there to free that memory. If you use malloc(), then free() should be used.

http://ptolemy.eecs.berkeley.edu/ptolemyclassic/almagest/docs/prog/html/ptlang.doc7.html

It is also very easy to go out of bounds in an array, for example inserting a value in an index larger than its size -1. With a vector, you can push_back() as many elements as you want and the vector will resize automatically. If you have an array of size 15 and you try to say arr[18] = x, Then you will get a segmentation fault. The program will compile, but will crash when it reaches a statement that puts it out of the array bounds.

In general when you have large code, arrays are used infrequently. Vectors are objectively superior in almost every way, and so using arrays becomes sort of pointless.

EDIT: As Paul McKenzie pointed out in the comments, going out of array bounds does not guarantee a segmentation fault, but rather is undefined behavior and is up to the compiler to determine what happens

Upvotes: 3

Thomas Matthews
Thomas Matthews

Reputation: 57688

Let us take the case of reading numbers from a file.
We don't know how many numbers are in the file.

To declare an array to hold the numbers, we need to know the capacity or quantity, which is unknown. We could pick a number like 64. If the file has more than 64 numbers, we start overwriting the array. If the file has fewer than 64 (like 16), we are wasting memory (by not using 48 slots). What we need is to dynamically adjust the size of the container (array).

To dynamically adjust the capacity of an array, a new larger array must be created, then elements copied and the old array deleted.

The std::vector will adjust its capacity as necessary. It handles the dynamic allocation of memory for you.

Another aspect is the passing of the container to a function. With an array, you need to pass the array and the capacity. With std::vector, you only need to pass the vector. The vector object can be queried about its capacity.

Upvotes: 2

Neer Patel
Neer Patel

Reputation: 441

One Security I can see is that you can't access something in vector which is not there.

What I meant by that is , if you push_back only 4 elements and you try to access index 7 , then it will throw back an error. But in array that doesn't happen.

In short, it stops you from accessing corrupt data.

edit :

programmer has to compare the index with vector.size() to throw an error. and it doesn't happne automatically. One has to do it by himself/herself.

Upvotes: -4

Related Questions