Re: sizeof array via pointer
* blargg:
Alf P. Steinbach wrote:
[...]
This is also where the (int)
cast came in handy - PR((int)cf[4]) actually displays the 0 instead of
nothing (which could mean anything).
Well you didn't do that in the code presented so far, so it appears to be
some
after-the-fact rationalization. But instead of the evil cast consider just
adding 0. For example. Only when your code is almost chemically free of casts
can you have any confidence that it is correct. Cast are just very very evil.
Here's an even terser way to promote a value to int if it's smaller:
+value
It's ungood because one has to think twice about it.
Source code is about communicating to people, not (so much) about communicating
to the compiler.
That's why a cast is bad even when it just does what an implicit conversion
would do, and why a non-idiomatic way such as '+value' is bad when there is more
easily grokked or established idiomatic way.
So, it should be
delete[] cf;
Yes, this was suggested by Vladimir as well. But does this really
delete
the char* created in f?
Yes.
f creates a character ARRAY, not a char*; this deletes the character
array that the char* POINTS TO.
That was discussed in the part of the posting that you snipped.
I discussed it because the OP asked, in the part of the posting you snipped, so
your comment, following quoting of me, is redundant as a comment to the OP.
It just irks me when people pretend to fail to understand plain English, change
contexts, snip relevant material, and so on, to create some misleading
impression, which, considering the above, is what it seems you did here.
The char* still exists after the delete,
though its value becomes indeterminate. You can still assign a new value
to the char* afterwards, for example.
Actually, formally that's a bit problematic. :-) But in practice you can, yes.
How does one check that some storage has been
successfully freed?
One doesn't.
Determine whether you're using a compiler that implements the standard.
If so, and if the pointer was one previously obtained from new and it
hasn't already been deleted, and you've invoked no undefined behavior,
then you can trust that it's been deleted.
I'm sorry but as far as I can see that's gobbledegook.
Possibly you meant that "then you can trust that a suitable 'delete' will
destroy the object and free the allocated memory".
But it's not necessarily the case that the memory has been freed, at least not
in the sense of being freed for general reuse, for the relevant deallocation
function (operator delete) may have been overridden for this class, or replaced
globally. In the words of Niels Bohr, "It depends on the dog". However, the
default, and the usual case, is that the memory is freed for general reuse.
Oh and use a compiler with a
debugging library that catches double delete and other violations.
That's a good idea.
Cheers & hth.,
- Alf
PS: for an introduction to pointers in C++, see my old pointers tutorial at
<url: http://alfps.izfree.com/tutorials/pointers/>.
--
Due to hosting requirements I need visits to <url: http://alfps.izfree.com/>.
No ads, and there is some C++ stuff! :-) Just going there is good. Linking
to it is even better! Thanks in advance!