How to make an array of class with constructor using pointer

[Swoorup]

I have a class named ScriptMarker which is initialised by Mission as a parameter in the constructor.

ScriptMarker* pStartMarker = new ScriptMarker(pMission);

And it is deleted this way.

delete pStartMarker;
pStartMarker = NULL;

So how will I able to make an array of class all initialised with the same parameter and how will I be able to delete it safely?

[laserlight]

One solution:

std::vector<ScriptMarker> StartMarkers(n, pMission);

[grumpy]

You can't do what you want directly with the array form of operator new and delete. There are some hacks you can use but, generally speaking, they often do not qualify as "safe" (a term that has various aspects).

There is, however, no need to directly use operator new or delete directly. That is inherently the dangerous approach, whether you are managing one dynamically allocated object or a million. Use a standard container instead.

#include <vector>

int main()
{
   std::vector<ScriptMarker> container(number_you_need, ScriptMarker(pMission));

     // do whatever you need with elements of the container
     //   even resize the container if you need to

    //  as we return, the container and its elements are cleaned up "safely".
   return 0;
}

The container will be safely destructed (and its elements) when it passes out of scope.

[Swoorup]

Thank you laserlight and grumpy
But
I need to delete it at the middle of function because the destructor does some important task too before the cleanup. Is there anyway?

[grumpy]

Resize the container to zero.

Better yet, break your function into smaller parts (implemented in separate functions) so the container is cleaned up when you need it to be.

A primary advantage of the standard containers is that their lifetime can be controlled using scope - if a function that creates a container returns, the container is cleaned up. If you have a function with two parts (one part that needs a container, and another part that doesn't) those two parts can be placed into separate functions.