memory and not using NEW ?

You could write a memory manager for your program, which will preallocate memory and then manage it more efficiently for your needs than the virtual memory manager provided by your operating system. You should get some hits if you google that.

This depends a lot on what language you're programming in, but Bacterius is on the right track assuming you're in C++.

The simplest example in C++ i can think of:

#include "CModel.h"

class NotSoGreatFactory {
protected:
	std::vector<CModel*> m_vPreAllocatedModels;
public:
	~NotSoGreatFactory {
		ClearReferences();
	}
	
	void ClearReferences() {
		for (int i = 0, size = int(m_vPreAllocatedModels.size(); i < size; ++i)
			delete m_vPreAllocatedModels[i];
		m_vPreAllocatedModels.clear();
	}
	
	CModel* GetModel() {
		if (m_vPreAllocatedModels.size() >= 1) {
			CModel* target = m_vPreAllocatedModels.pop_back();
			target->Reset();
			return target;
		} else return new CModel();
	}
	
	void ReturnModel(CModel* model) {
		m_vPreAllocatedModels.push_back(model);
	}
};

// And then in your code
NotSoGreatFactory modelFactory;
for (int i = 0; i < 100000; ++i) {
	CModel* tempModel = modelFactory.GetModel();
	// Do some stuff until temp model is no longer needed
	modelFactory.ReturnModel(tempModel);
}

In this scenario we only ever allocate one model.

Start with that, see how you can improve.

just been going though my code and i create lots and lots of CModel by doing

CModel temp = new CModel()

Is the slow part the memory allocation, or the code inside CModel's constructor?

Yes, it's called object pooling. Here's the wikipedia entry for it.

What it basically does is to create all objects beforehand, and store them inside a special collection (the pool). When you need one, you get an object from the pool, and use it. After you are done, you return the object back to the pool.

This requires a small modification to your CModel class. You need to include "enabled" and "disabled" states to your class. When you return the object back to the pool, it "disables" that instance. When you query it from the pool, it re-"enables" it back.

just been going though my code and i create lots and lots of CModel by doing

CModel temp = new CModel()

Is the slow part the memory allocation, or the code inside CModel's constructor?

I'm with Hodgman on this.

Even though there are better alternatives to what you're currently doing, 900 allocations won't stress a general-purpose allocator.

What is the constructor doing?

just been going though my code and i create lots and lots of CModel by doing

CModel temp = new CModel()

then putting it into a container

in the end i end up doing this about 900 times and its slowing the loading down,

is there a good way to preallocate it in one go then point to it ,

if so is there any good tutorails i can use

Doing a simple test, calling 900 new on a simple class, takes 45 microseconds. If you are doing this 900 times, and it is seen as slow from a human perspective, then we can say for sure that it is not the memory allocation that is the problem. That means that using a special allocation pool will not help you.

Either it is the constructor that is the problem, your measurements are wrong, or I don't understand the question.

Since the OP seems to be doing this on a model class my first assumption would be that the slowdown is caused by file i/o rather than memory allocation.

Using a few larger archives rather than hundreds of small files can greatly speed this process up on conventional hdds.

The OP might also benefit by reserving space in the container (resizing a vector for example isn't extremely fast)

A mempool (preallocation of space) is typically used when the objects are being deallocated and reallocated frequently.

How large is sizeof(CModel) and what is the ctor doing?

Without measurements to guide your actions, you're not optimizing you're just randomly changing code in the hopes that it might have an effect.

Measure twice. Refactor once.