CODEWITHSUNDEEP
c++arrays
Rocket
Rocket

Reputation: 553

can we check the size of dynamic array on runtime

I create an array of size int arr[50]; but I will insert value in it during compile time , like my solution will insert 10 values in it after performing some function (different amount of values can come) , Now in second part of my program I have to loop through the array like it should iterate <= total values of array like in int arr[50] my program save 10 values , it should iterate to it only 10 times but how I can get that there is only 10 values in that array.

arr[50]=sum;
for (int ut=0; ut<=arr[100].length();ut++)

Though i know ut<=arr[100].length() is wrong , but its just assumption , that function will work if I solve condition in this way.

Edit:

I know we can use vector , but I am just looking that type of thing using array.

Thanks for response

Upvotes: 0

Views: 242

Answers (1)

Nasser Al-Shawwa
Nasser Al-Shawwa

Reputation: 3653

First of all, the array you show is not a "Dynamic Array". It's created on the stack; it's an automatic variable.

For your particular example, you could do something like this:

int arr[50];
// ... some code
int elem_count = sizeof(arr) / sizeof(arr[0]);

In that case, the sizeof(arr) part will return the total size of the array in bytes, and sizeof(arr[0]) would return the size of a single element in bytes.

However, C-style arrays come with their share of problems. I'm not saying never use them, but keep in mind that, for example, they adjust to pointers when passed as function arguments, and the sizeof solution above will give you an answer other than the one you are looking for, because it would return sizeof(int*).

As for actual dynamically allocated arrays (where all what you have is the pointer to that array), declared as follows:

int *arr = new int[50];
// ... do some stuff
delete [] arr;

then sizeof(arr) will also give you the size of an int* in bytes, which is not the size you are looking for.

So, as the comments suggested, if you are looking for a convenient random access container where you want to conveniently and cheaply keep track of the size, use a std::vector, or even a std::array.

UPDATE

To use a std::array to produce equivalent code to that in your question:

std::array<int, 50> arr;

and then use it like a normal array. Keep in mind that doing something like arr[100] will not do any bounds checking, but at least you can obtain the array's size with arr.size().

Upvotes: 2

Related Questions