I find sometimes the journey is as entertaining as the destination, so
let me indulge with how I got to what I'm thinking...
So, I'm looking at some code. there is an object like FooManager,
that manages a list. It has functions like RemoveFoo(Foo *),
AddFoo(Foo *), etc. (Ah, so many thoughts - why not just "Remove",
instead of "RemoveFoo", since we know the context, why even wrap the
list at all (this one is easy - the FooManager does more than just
wrap a list), etc).
Anyhow, RemoveFoo(Foo *) linearly searches the list for the matching
Foo * (by pointer comparison).
1. So I think, hey, really, this should be a set, not a list. And by
looking at what else we do with the list, yeah, a set would be better.
2. And really, shouldn't it be a list of smart_ptr<Foo> or somesuch?
(probably intrusive_ptr, as Foo has its own ref-counting, but
whatever.)
3. And what about this pointer comparison?
4. etc. Just so much rewriting could be done. How do you decide where to stop!
So, about the pointer comparison:
Since an allocator can (and, surprisingly to some, often does) reuse
the same pointer that was previously allocated and freed, how do I
even know that the Foo * that should be removed, is really the "same"
Foo * that is in the list. (Well, in my case, if I assume decent
programming, and since the Foo's are ref-counted, no one should have a
pointer to a deleted Foo, but that is assuming decent programming).
So, my first thought is that each Foo should have a unique,
non-recycled ID (GUID, ever incrementing int/long/etc, or something).
Then I would know if I _really_ had the same Foo. And so I could do
that. But we are now actually at the point where I will probably skip
the whole idea and assume decent programming exists and there is no
real problem.
Then, I started wondering - I've had this problem before, thus where's
the general solution. And what would it be? And *should* it be (ie
should it exist)?
So that's my question. What would it be. Would it be an allocator
that included space for, and initialized, the ID, and then also
special pointer type, where the pointer comparison checked the ID? Is
it just dumb to try to be robust against bad programming (to this
extent)? Would the Object ID be useful beyond that - ie to
distinquish between:
1. these 2 objects are equal
and
2. these 2 objects are the same object (ie there is only 1 object, not 2)
Thoughts?
