Operator new[] vs. Array

Can someone clearly explain why you would do this:

Code:

---

const unsigned int MAX_SIZE = 120;

MyClass *myInstance = new MyClass[MAX_SIZE];

---

istead of just this:

Code:

---

MyClass myInstance[MAX_SIZE];

---

Also how would you do this if MAX_SIZE is unknown at compile time?

I have looked around, but nothing explains these concepts clearly, either that or my head is thicker than I thought it was...

Thanks in advance,

Cheers!

EDIT:
Let me rephrase; I know that a better method would be to use:

Code:

---

vector<MyClass> myInstance;

---

But I also really don't want to go back through all lines of code and change all of that.

I am working on a program that reads data into this array and the data file will not always be the same size. I want the program to be able to adjust accordingly, without having to recompile. So, is there a way to dynamically allocate an array of MyClass, without knowing the size of the array? Every method I have tried, has called bad_alloc to be thrown.

Quote:

---

So, is there a way to dynamically allocate an array of MyClass, without knowing the size of the array?

---

Without knowing how much you are allocating?

You might need to do it the same way vector does it.

Quote:

---

Originally Posted by Phyxashun

Can someone clearly explain why you would do this:

Code:

---

const unsigned int MAX_SIZE = 120;

MyClass *myInstance = new MyClass[MAX_SIZE];

---

istead of just this:

Code:

---

MyClass myInstance[MAX_SIZE];

---

---

I think they are different. The first one is dynamic allocation, the second one is static allocation.
For dynamic one you can write like this:

Code:

---

MyClass *myInstance = new MyClass[];

---

For static allocation, size must be known, different with dynamic allocation.

Check here:
http://www.dreamincode.net/forums/showtopic38457.htm

Quote:

---

Originally Posted by auralius

I think they are different. The first one is dynamic allocation, the second one is static allocation.
For dynamic one you can write like this:

Code:

---

MyClass *myInstance = new MyClass[];

---

For static allocation, size must be known, different with dynamic allocation.

Check here:
http://www.dreamincode.net/forums/showtopic38457.htm

---

No, you cannot, that is illegal.

Code:

---

MyClass* myInstance = new MyClass[SIZE];

---

Even if it's dynamic, it still needs the size. You cannot change the size later, either. You must allocate a new array, copy all data over, and then delete the old one.
But std::vector handles all this for you.
If you need a faster alternative, you need to look into platform solutions. I made a much faster vector using Win32 API (keep in mind that it would only be faster if the vector is growing constantly and much; otherwise it would just be a waste of flexibility).

I did try and it can compile...
Let's make it simple:

Code:

---

char *a = new char [];
a[100] = '0';

---

I think, "technically", it is just ok. But i don't think it is a good way of programming. :)

No, it's not possible. You MUST specify a size. And that size must be large enough to accommodate that 100th element, or you will get undefined behavior.
If the compiler accepts it, technically it will use 0 as size, and that will give you nothing good, if anything.

Quote:

---

Originally Posted by auralius

I did try and it can compile...
Let's make it simple:

Code:

---

char *a = new char [];
a[100] = '0';

---

I think, "technically", it is just ok. But i don't think it is a good way of programming. :)

---

g++ says:

Code:

---

foo.cpp: In function `int main()':
foo.cpp:3: error: expected primary-expression before ']' token

---

Line 3 happens to be the line with "new" on it.

--
Mats

Visual C++ actually accepts it, but this clearly shows that it is non-standard.

Quote:

---

Originally Posted by Phyxashun

EDIT:
Let me rephrase; I know that a better method would be to use:

Code:

---

vector<MyClass> myInstance;

---

But I also really don't want to go back through all lines of code and change all of that.

I am working on a program that reads data into this array and the data file will not always be the same size. I want the program to be able to adjust accordingly, without having to recompile. So, is there a way to dynamically allocate an array of MyClass, without knowing the size of the array? Every method I have tried, has called bad_alloc to be thrown.

---

No you can't do that. You will have to change at least the declaration and allocation of your array, and preferably how it is used. It is possible to create a type that will behave the way you want it to using the same interface, but the simplest option is to use a vector, and change the way you add elements to follow vector conventions. If you don't care for speed you can also use a map<int,Type>, so that "array[100]=initialValue" syntax works.

Quote:

---

Let me rephrase; I know that a better method would be to use:

Code:

---


vector<MyClass> myInstance;

---

But I also really don't want to go back through all lines of code and change all of that.

---

That is the best option and you should use that from the start.

However, how large is the code? Vector has a rather similar interface to arrays, so you might not need to change that much lines of code.

For example, whenever you have a function that accepts a pointer to array and a size variable you can obtain these from the vector:

Code:

---

void foo(X* x, unsigned size);

vector<X> vec;
foo(&vec[0], vec.size());

---

It's only 10300 lines, but it is organized very well. I do believe vector is the best route, so I am going to just go through and change all of the assignments to push backs, etc. I was just almost certain that there had to be a way to dynamically allocate an array without knowing the size, but I am probably wrong.

Thanks for all of the insights.

Cheers!

Quote:

---

Originally Posted by Phyxashun

I do believe vector is the best route, so I am going to just go through and change all of the assignments to push backs, etc.

---

Depending on your exact requirements, you might create the vector with the given size and then use assignment as needed instead of creating an empty vector and then inserting as needed.

Quote:

---

Originally Posted by Phyxashun

I was just almost certain that there had to be a way to dynamically allocate an array without knowing the size, but I am probably wrong.

---

But there is, as in using dynamic memory allocation, as you mentioned in your own first post. It so happens that this would mean manual memory management unless you use a container.

This is what the vector template is for. You can use C idioms if you must however. There is a nice little function called realloc(), which is definitely not a recommended C++ idiom. In fact I don't even think there is a standard equivalent via new and delete.

Here's a nice algo. trick by the way to make reallocation of an array efficient. Keep two size variables, the memory size and the amount used. When you call realloc, grow your memory size by 50% if it doesn't already fit. The complexity of this algorithm is still linear! You typically only rarely have to resize (call realloc) as you grow your array.

Quote:

---

Originally Posted by SevenThunders

Here's a nice algo. trick by the way to make reallocation of an array efficient. Keep two size variables, the memory size and the amount used. When you call realloc, grow your memory size by 50% if it doesn't already fit. The complexity of this algorithm is still linear! You typically only rarely have to resize (call realloc) as you grow your array.

---

std::vector's push_back does something like that, though with a factor of 2 instead of 1.5. std::vector's reserve() can be used to expand by a factor of 1.5.

I don't think the standard specifies the factor. I think VC++ implementation uses a smaller factor than GCC, which might actually be 1.5.

Quote:

---

Originally Posted by laserlight

std::vector's push_back does something like that, though with a factor of 2 instead of 1.5. std::vector's reserve() can be used to expand by a factor of 1.5.

---

Factor of 2 expansion is how you see it presented in most algo. textbooks. I like a factor of 1.5 since it requires a little less memory at the expense of a little more resizing. Both algorithms are of course linear complexity. That is the complexity of appending n items is proportional to n , O(n).

Also a factor of 1.5 is easy to generate via a shift and an add once you take care of end cases.

Quote:

---

Originally Posted by anon

I don't think the standard specifies the factor.

---

I double checked, and I think that you are right, the standard only seems to specify amortised constant time for std::vector's push_back().