Thread: Quick question about memory allocation

high, i have a function which stores two char*, name and key, into a linked list. This is a different function, which creates the char[] and passes it onto the function which places it into a linked list. My question is if I want to delete name and key later on, will it work. Im thinking that once ive passed the pointer for the char[] to the linked list, how will the function from my linked list class know the size of the strings. Does it work any way, or is there another way to do it?

Code:

char* testname;
char* testkey;
testname = new char[32];
testkey = new char[16];

Yes, new actually saves the size of the allocated memory in a memory block to where you allocated memory. You can actually get the size with _msize (warning: platform dependant), so I'm guessing that's how delete [] keeps track of it.
Unless it's a class, delete [] works even on void* pointer.
Just be sure to use delete [] on arrays and delete on non-arrays. And yes, you're better off with a string class, such as std::string.

with delete [], what would be the syntax of that, is it delete [] testarr or delete testarr[]
im using char[] because im reading and writing memory to another program, and its just easier to have buffers with the bytes i need instead of having to go through a list of functions.

Code:

delete [] ptr;

With std::string, you can just call c_str() to get your C-style formated string to work with. As long as you let you string to the memory handling (resize, allocate, etc) you should be fine.

Yes, it works. You can even cast it to void* (because delete takes a parameter of type void* anyway) and it will still work.
However... It will not work on classes! When allocating and deleting classes, you must not change the type of the pointer.
And don't use char, use a C++ object instead. Want a string? Use std::string. Want a buffer? Use std::vector.

Thanks.

I'm writing a fast list-class with an array underneath and insertion and deletion in O(1). I'd use the stl vector otherwise.

Undefined, you say.

What if I do this:

Code:

delete[] (char *) mArray;

Originally Posted by Salem

> ObjectType *mArray = (ObjectType *) new char[sizeof(ObjectType) * iInitialSize];
That's just HORRIBLE.

Sure.

What's wrong with
ObjectType *mArray = new ObjectType[iInitialSize];
- No casting
- No worrying about whether you got the right type in the sizeof
- The proper constructors get called.

Which is the problem, I just wanted a raw memory block.

Originally Posted by CornedBee

Still undefined, unless you explicitly call the destructors.

Oh, the destructors, that's right... Always some detail.

If you just want a raw memory block to place objects in, don't use new. Use operator new:

Thank you, that looks better. I just settled for char after reading a stray googled article on new which used char to demonstrate placement syntax.

Originally Posted by iMalc

Then combined with:
ObjectType *mArray = (ObjectType *) new char[sizeof(ObjectType) * iInitialSize];
You're hoping two wrongs make a right?

You should listen to Salem.

What, so that's just a linked list within a memory pool? Or are you storing items in order in memory contiguously and claiming that is O(1)?

A linked list would imply links.

The class uses an array so the objects can be stored in sequence and not be fragmented across memory.
O(1) is achieved for insertion by inserting items at the end of the list.
O(1) is achieved for deletion by replacing the deleted item with the last one in the list.

This stuff with me looking to allocate memory without constructors and other fun headaches is just some smaller optimizations for the heck of it.