delete dynamically allocated char array

is there anything specific we need to do to delete a dynamically allocated char array.

i'm using the below code, and it is providing my asert errors.

Code:

	delete [] messagePtr1;
	messagePtr1=NULL;
	delete [] messagePtr2;
	messagePtr2=NULL;
	delete [] messagePtr3;
	messagePtr3=NULL;

it works in the same program for an integer array.

please someone, if you know of an error in my syntax please tell.

How you delete something depends entirely on how you allocated it in the first place

Plus, if you've corrupted memory, say by stepping off the end of the array, your delete code could be correct, but is failing because of problems elsewhere

i allocate it similar to the following.

Code:

 
char* messagePtr;

messagePtr=new char[]="System Check";

isn't this correct?

nope, it's not correct, I wonder whether your code even compiles, in case it compiles, you are allocating memory by "new char[]" and then, instead of assigning it to messagePtr and setting its contents to "System Check", the address of "System Check" assigned to messagePtr (it's a char array after all), causing a memory leak.
Later when deleting messagePtr (delete [] messagePtr) you are actually trying to delete "System Check" memory, and since it's not valid heap memory, your getting an error.
The correct way to do it is:

Code:

#define MAX_MESSAGE_SIZE 1024

char* messagePtr;
messagePtr = new char[MAX_MESSAGE_SIZE];
strcpy(messagePtr, "System Check");

// later
delete [] messagePtr;

Anyways, instead of using char* and heap memory, why don't you simply std::string?

Code:

#include <string>
using namespace std;


string message;
message = "System Check";

// no need to delete anything, std::string takes care of such stuff for you

Why do you allocate heap memory at all if you then just copy into the newly allocated buffer a static string?

I'm new to dynamic memory.
I assumed it is better to create and delete it.
But from your posts I'm assuming I should allow it to die out naturally.

There's no way memory can "die out naturally", if you don't free it, it will cause a memory leak; however, some classes of the standard library encapsulate the memory management thing, so you don't have to worry about it.

Code:

 
#define MAX_MESSAGE_SIZE 1024

char* messagePtr;
messagePtr = new char[MAX_MESSAGE_SIZE];
strcpy(messagePtr, "System Check");

// later
delete [] messagePtr;

Would this print the information inaccurately (trailing garbage values)?
Suppose I use the following.
Forgive me for not trying this myself, but I'm no where near an operable c++ compiler.

Code:

 
cout<<messagePtr;

------------------------------------------------------------------------------
//Displays (I believe)
System Check 00000000000000000000000000000000000000000000000000 00000000000000000000000000000000000000000000000000 00000000000000000000000000000000000000000000000000 000000
------------------------------------------------------------------------------

Another follow up question is.
Does the string class automatically deallocate the memory?
Or is there follow up code that needs to be executed to prevent a memory leak?