In article <11**********************@m79g2000cwm.googlegroups .com>,
pr***************@yahoo.com says...
Hi everyone,
Im just starting out with C++, and am curious to know how "delete []
<pointer>", knows about the number of memory locations to free.
It's required to do so, but exactly how it does so is up to the
implementation.
I read somewhere that delete frees up space assigned to <pointerby
"new". Does "new" create a list of pointer names and the size of the
memory array they point to? I also read that some compilers may store
the number of consec mem locations a pointer points to, just before the
first data element. Is that correct?
In both cases, the answer is a definite maybe -- it can keep track of
all of the data in one place, or it can put data in each node as it's
allocated, or whatver else it prefers.
Also, if i used malloc() to make <pointerpoint to a number of memory
locations, will calling "delete [] <pointer>" still work?
If you use malloc to allocate some memory and then use delete on that
memory, the results are undefined -- it might work for some sufficiently
loose definition of "work". Then again, it might simply crash and burn,
or it might do just about anything else.
if yes, how
does delete here know the number of memory locations to free? does the
malloc() implementation in C++ also create a pointer/memsize list like
"new"?
It could, but it's not required to do so -- allocating memory with
malloc and then attempting to delete it isn't required to work at all.
And lastly, if i made another pointer <pointer2point to the same
location as <pointer>, would calling "delete [] <pointer2>" still free
up the correct number of locations?
If I understand your question correctly, yes. What you get back from new
is an address. You have to pass that address to delete exactly once --
but the pointer you store the address is makes no difference at all.
To summarize: if you use new to allocate some memory, you must use
delete exactly once on the address you get from new. If you use new[] to
allocate the memory, you must use delete[] exactly once on that address.
If you allocate some memory with malloc, you must call free exactly once
with that address malloc returned.
Beyond that, exactly how each of these accomplishes what it's supposed
to is up to the implementer. When you do something like:
struct whatever {
whatever() { std::cout << "ctor\n"; }
~whatever() { std::cout << "dtor\n"; }
};
whatever *w = new whatever[10];
// ... other stuff here
delete [] whatever;
The 'new' is reuqired to use whatever's ctor to create each of the ten
objects, and the delete is required to use whatever's dtor to destroy
each of those ten objects. How it knows there are ten objects to destroy
is entirely up to it. It might allocate some extra memory and store it
along with the object. It might have a separate table of sizes of
objects. It's even possible that it could (for one example) use the
exact value of the pointer to tell it what it needs -- assuming, for the
moment, a CPU that had no alignment requirements, it could (for one
example) make some bits in the address it assigns equal to the size of
the array that was allocated. Obviously this has the potential for
wasting some address space, but on (for one example) a machine with 64-
bit addressing, that's not likely to be a problem at least in the near
future.
--
Later,
Jerry.
The universe is a figment of its own imagination.
