[boost] Interest in HeapAware mixin?

3 Jul 2008

      Hi everyone,

Would there be any interest in a mixin class that signs an object as being
on the stack or the heap? Any class that needs to know if it can delete
'this' can (possibly multiply) inherit from class HeapAware, and will gain a
member function on_heap() that returns whether the object was dynamically
allocated.

A similar idea is discussed in More Effective C++, item 27, but unlike that
approach, my implementation works correctly for arrays. It also does all the
work during construction, so that checking on_heap() just returns a preset
bool. The extra cost at construction is a small constant. It is not yet
thread safe, but could be made so reasonably easily. Unlike some similar
classes, it uses nothing compiler specific, even for arrays, which is where
people usually need to "cheat". In particular, for arrays it makes no
assumptions about where in the allocated memory the objects are constructed,
and so alignment issues or extra compiler bookkeeping don't cause any
problems.

I currently use this class within a 3d mesh library I maintain. I have
triangles that belong to multiple meshes, and I want updates to a triangle
to be noticed by all meshes that contain it, so that they can mark their
cached mesh statistics as being out of date. This means I need an event
listener mechanism. I also want triangles ownership to be shared among the
meshes, so that deleting a mesh deletes any triangles that no other mesh
currently contains. I built a two way smart pointer / event listener class
that maintains a single list that serves as both listeners and owners. The
HeapAware class that I am proposing for Boost was invaluable to me, because
it allowed me to disable self deletion for triangles on the stack.

The snippet below demonstrates how HeapAware can be used. (Obviously this a
trivial example). My implementation produces the correct output for all
these cases, as well as for globals, statics, and objects created with
placement new and placement new[]. It also works correctly with copy
construction, which some other implementations fail at.

class Widget : public HeapAware {};

int main() {
  Widget stack_w;
  Widget* heap_w = new Widget;
  Widget stack_copy(*heap_w);
  Widget* heap_copy = new Widget(stack_w);
  Widget stack_array_w[2];
  Widget* heap_array_w = new Widget[2];

  printf("Stack Widget: %d\n", stack_w.on_heap());
  printf("Heap Widget: %d\n", heap_w->on_heap());
  printf("Stack copy of Heap widget: %d\n", stack_copy.on_heap());
  printf("Heap copy of Stack widget: %d\n", heap_copy->on_heap());
  printf("Stack array widget 0: %d\n", stack_array_w[0].on_heap());
  printf("Stack array widget 1: %d\n", stack_array_w[1].on_heap());
  printf("Heap array widget 0: %d\n", heap_array_w[0].on_heap());
  printf("Heap array widget 1: %d\n", heap_array_w[1].on_heap());

  return 0;
}

Thanks!
-Corey Goldfeder