Re: Making a smart pointer which works with incomplete types
* blargg:
Alf, if I understand your approach, this summarizes its essence:
No, it's not how I would do things.
Also bear in mind that I described at the start how to do things properly, which
is utterly simple.
All the rest in response to particular silly arguments; not a good way to do things.
// incomplete.cpp
template<typename T>
void delete_t( T* p );
class Foo; // incomplete
void incomplete( Foo* p )
{
delete_t( p );
}
Huh?
// complete.cpp
This is the same filename as before.
template<typename T>
void delete_t( T* p ) { delete p; }
class Foo { /* ... */ };
void incomplete( Foo* );
void complete()
{
delete_t<Foo>( 0 ); // instantiate where Foo is complete
incomplete( new Foo );
}
Double huh.
The delete_t function and calls to it would be in the library header. The
user just #includes a special library header that defines delete_t, so
that when uses some function in the library where Foo is complete, the
library causes delete_t to be instantiated there. Then delete_t can be
called from other functions in the library when Foo is incomplete.
Third huh, not sure what you're trying to say here.
The problem is if you have two users and types, where the incomplete type
is deleted in the same translation unit as the complete type is created
and delete_t is instantiated for it. In this case, it will get
instantiated for the incomplete type as well, causing an error.
Actually this paragraph makes a little sense, if all before it is ignored.
I can't make head or tails of the logic leading up to the conclusion, but it's
true that blindly doing as my latest example (which addressed a particular
technical point) would not support multiple incomplete types, if you somehow
managed to end up with such situation -- I have never.
However, supporting multiple incomplete types is trivial.
And the proper way of doing that is what I showed *first*.
It can also trivially be done via this latest code, just not applying it blindly
(note that the latest code is not a good way to do things, it just addresses a
technical point in a discussion).
Juha's original goal was to make a smart pointer class that 1) can be used
with an incomplete type, only requiring that the type be complete when the
smart pointer is constructed, and 2) doesn't require any per-instance
storage beyond a single pointer to the object itself.
No, that's not what the latest discussion has been about.
In response to simple way of doing it it was required that user should not have
to write a destroy function.
Silly, idiotic, not what any sane programmer would require, but.
I absolutely cannot
understand why you have responded to Juha in the manner you have
You mean, by explaining things carefully, and even posting working code?
I have
to assume he has done something to you in the past and this is some kind
of revenge.
Then if I had been influenced that I think it would be in the opposite
direction, towrads not helping, not explaining these basics, not posting
complete code, so on.
You make me wonder why you're posting an insinuation that I've been less than
helpful.
But then, most of this article didn't make sense.
Cheers & hth.,
- Alf
--
A: Because it messes up the order in which people normally read text.
Q: Why is it such a bad thing?
A: Top-posting.
Q: What is the most annoying thing on usenet and in e-mail?