2

I don't understand the need for dynamic arrays. From what I understand so far, dynamic arrays are needed because one cannot always tell what size of array will be needed at runtime.

But surely one can do this?:

cin >> SIZE;
int a[SIZE];

So what's the big deal with dynamic arrays and the new operator?

Phonon
  • 12,549
  • 13
  • 64
  • 114
Steve
  • 29
  • 1
  • I just found this:http://stackoverflow.com/questions/2610449/why-does-c-allow-variable-length-arrays-that-arent-dynamically-allocated I would appreciate more info though if there is – Steve May 19 '11 at 20:39
  • 4
    How much programming have you done in your life? Are you telling me that never came across the need to have a dynamically growing data-structure? – Björn Pollex May 19 '11 at 20:41
  • 7
    "*But surely one can do this?*" Nope, actually, you can't. – ildjarn May 19 '11 at 20:54
  • 1
    Dynamic arrays exist solely for the purpose of implementing `std::vector` ;-) – fredoverflow May 20 '11 at 05:28

6 Answers6

7

Firstly, that is a compiler extension and not Standard C++. Secondly, that array is allocated on the stack, whereas operator new allocates from the heap, which are two very different places that drastically affects the lifetime of the array. What use is that code if I want to return that array? Thirdly, what are you gonna do if you want to resize it?

Puppy
  • 144,682
  • 38
  • 256
  • 465
1

SIZE is a variable which means it's value can be modified. Array by definition, can neither grow nor shrink in it's size. So, it's size needs to be a compile time constant.

Mahesh
  • 34,573
  • 20
  • 89
  • 115
1
cin >> SIZE; int a[SIZE];

Some of my users have a hard enough time using a mouse, and you want them to tell my application how much memory to allocate?

mikerobi
  • 20,527
  • 5
  • 46
  • 42
  • Hehe, I get the point. However this question stemmed from looking at elementary code (in a textbook) looping through student scores in a test. I reckoned the user could specify how many students there are. No rocket science there. But again, I get the idea. There are more complicated things going on out there, than processing student scores.. – Steve May 19 '11 at 20:49
0

Dynamic arrays are very handy ... suppose you keep generating objects, and you have no idea how many objects might be generated (i.e., how much input might you get from someone typing an answer at a prompt, or from a network socket, etc.)? You'd either have to make predictions on what appropriate sizes are needed, or you're going to have to code hard-limits. Both are a pain and in the case of hard-limits on arrays, can lead to allocating way too much memory for the job at hand in order to try and cover every possible circumstance that could be encountered. Even then you could incur buffer-overruns which create security holes and/or crashes. Having the ability for an object to dynamically allocate new memory, yet keep the association between objects so that you have constant-time access (rather than linear-time access like you'd get with a linked-list), is a very, very handy tool.

Jason
  • 31,834
  • 7
  • 59
  • 78
0

In the early days of C, space was made on the stack when you first entered a function and the size of the stack was untouched until you called another function or returned. This is why all variables needed to be declared at the top of a function, and why array sizes needed to be known at compile-time, so the compiler could reserve a known amount of stack.

While C++ loosened the restrictions of variable declaration, it still kept the restriction of knowing the stack requirements at compile time. I don't know why.

As noted in the link in the comments, C finally allowed for dynamic size arrays. This came after C and C++ were split, so C++ didn't automatically gain that capability. It's not uncommon to find it supported as an extension in C++.

Mark Ransom
  • 299,747
  • 42
  • 398
  • 622
  • stack requirements were kept because of two things: It was too much effort to implement to c++, and also because std::vector already solved the same problem. – tp1 May 19 '11 at 21:00
  • stack requirements are also used when unwinding the stack during exceptions and it makes life a lot easier for debugger. A C debugger can be used with C++, it will report the mangled names for the symbols. – IronMensan May 19 '11 at 22:09
  • The rationale offered here gets a bit shaky when you realize that local variables don't need to be on the hardware stack. You could easily build a second stack for arrays with local scope, and from a security viewpoint (buffer overflows!) this would make a lot of sense. – MSalters May 20 '11 at 09:20
0

Personally I prefer:

std::cin >> size;
std::vector a(size);

Later, as others have mentioned, you could do something like ...

std::cin >> size;
a.resize(size);

...but, and this is probably the key point, you don't have to if you don't want to. If your requirements and constraints are such that they can be satisfied with static size arrays / vectors / other data structures then great. Please don't think you know enough about everybody else's requirements and constraints to remove from them a very useful tool.

andand
  • 17,134
  • 11
  • 53
  • 79