Thread: multiple indirection...

ptr = (char **) calloc (num_ptrs, sizeof(char*));

is it didn't work?

ptr=(char **)calloc(NumPtrs,sizeof(char))

This is just a two dimensional array. Why do you need to declare and allocate this way?

Bubba said that it would just be a two-dimensional array.

• To keep a log of allocated memory, track each memory pointer by a handle.
  
• To de-allocate call your own type of Free() function and mark the area as free.
  
• To allocate, check the memory for availability against space and other handles and then return a unique handle to that memory.
  
• Call another function which requires a handle and returns a void pointer to the memory area. The pointer then can be typecasted to another data type by the programmer.
  
• You should have functions that will lock and unlock memory areas.

Managing memory this way can be tedious, very confusing, and very complex especially if you want to code all the functions yourself.

If a run-time error happens or an exception is thrown then iterate through the array or linked list of handles and call your version of free() for each.

Another implementation

You could also implement some type of binary or quad-tree that would allow you to know which handles need to be freed. Parent nodes would be the first memory object. Subsequent nodes would be memory that was allocated after the parent node, but still belong to the parent object.

This would allow you to free up memory within the parent object tree and would also let you know which subsequent memory handles needed to be freed. Anything that was a child node of the node that you wish to free, would need to be freed. If you wish to delete the parent node, or the entire object, then all subsequent nodes would need to be freed, thus freeing all memory taken up by the object. Nodes would be indentified by their handle and would remain transparent to you the programmer. The programmer would just be accessing the memory handles w/o really knowing/caring how everything worked, just that it did.

Example:
Object - Handle

ParentObject - 0
..Child1 - 1
....Child11 -(First Child of Child1) - 2
..Child2 -3
....Child21 -(First Child of Child2) -4


Let's say to want to delete memory handle 4:

• Does Child21 have children: No - delete/free child21

To delete memory handle 1:

• Does Child1 have children: Yes-next
• Does Child11 have children: No - delete/free child11,child1

To delete the ParentObject:

• Does ParentObject have children: Yes - next
• Does Child1 have children: Yes - next
• Does Child11 have children: No - delete/free child11, child1
• Does Child2 have children: Yes - next
• Does Child21 have children: No - delete/free child21,child2
• Delete/free ParentObject

Delete/Free means delete memory object and free handle.

Unfortunately to implement this, you will use a linked list of sorts, but it will guarantee that all memory objects are freed properly. This could be easily implemented recursively or if you do not want the function call overhead or do not have enough stack space, you could do it in a do:while.

All that work and I was not even logged in.

The long post was from Bubba. I was disconnected while responding to the post and I guess when it reconnected it did not log me in.

Anyways, doubleanti, I put a lot of thought into my response so I hope it helps if not just a little.

Why don't you like arrays?
In c++ allocate your dynamic arrays with new.

char* a = new char[180];

delete[] a;