Thread: When to Allocate or Not to Allocate

What factors should one use to determine when you should use the new and delete operators? I am completely comfortable with pointers, is there a reason to dynamicaly allocate members of a class, if the class instance its self is dynamically allocated? Should all the members of a class be pointers, or just some of them? How do you know whats the best? Whats the speed impact? Whats the best way to do it? I clearly have alot of questions. Does someone have a good link to an article on the subject?

I am taking a hard long look at where I am in the development in my program before I continue any father. Im looking at basic concepts of my program and trying to decide if I am doing things the best way they can be done. This is one of the gray areas I have been debating with myself.

I read the FAQ and all the articles before I posted, I dont think im getting my point across, or either you think I just started with C++. Lets take this for example.

Code:

class A {
public:
A() {
  i = new int[30];
}
~A() {
  delete i;
}
private
  int* i;
};

class B {
public:

private:
  int i[30];
};

Both will work and offer the same function, if things work the way I think, then B has a larger footprint in active memory than A. And in the case of very large classes that may take up KBs of space, how does this play out? What are the pros and cons of the two methods?

Dynamically allocated members are not initialized until you, the programmer, tell the computer to do so. So in the event that maybe you don't want to allocate some memory unless you need to you should make it dynamic.
I think 'initialized' may not have been the proper word, or I may just be confused. So, your saying that if the class needs the data member to always exist during the course of the program execution, then the data member in question should not be dynamically allocated. Even if the data member is very large? Having very large data members declared directly into the class will bloat the memory size of the class, correct?

Try this: don't dynamically allocate any memory for any program. If you can do it, then no worries. If you can't, then use dynamically allocated memory.

Code:

class A {
public:
A() {
  i = new int[30];
}
~A() {
  delete i;
}
private
  int* i;
};

class B {
public:

private:
  int i[30];
};

What if you may need to store 10,000 ints or 5 ints, but you aren't sure which until you get some user input? You could write the program with an int array: i[10000]. But, if you only end up needing room for 5 ints, then you set aside memory that you didn't need. That's not real efficient, but with ints that's probably no big deal. Now what if you didn't know whether you were going to need to store 10,000 objects or 5 objects, where each object had 30 member variables, some of which were other objects. The memory required may be significant, so you might want to wait until runtime to allocate the memory to see how much memory you really need.

The approach mentioned by anonytmouse is to forget about dynamically allocating memory and use vectors and the other containers provided in the C++ Standard Template Library. Vectors start off empty and they can grow their size automatically. So, if you need to store 10,000 things, you add 10,000 things to the vector; if you only need to store 5 things, then you just add 5 things to the vector. A beginning C++ book called "Accelerated C++"(Koenig, Moo) takes that approach and starts off teaching the reader how to use vectors--before even explaining what arrays and pointers are. Personally, I think the book is a bit advanced for a beginner. It's fairly short as well--maybe an inch thick--so you might want to check it out.