Advanced C++ Community

This is x-posted from an entry in my journal.

I'm quite pleased with myself. :-) I've been participating on stackoverflow.com recently. HazyBlueDot had an interesting question in which (s)he was trying to use ::boost::function to get around a broken library interface.

In particular, the library interface allowed you to register a callback function, but it did not provide you a way of giving it a void * or something to pass back to you so you could put its call of your function back in context. HazyBlueDot was trying to use boost::function in combination with boost::bind to add in the pointer and then call his own function. The only problem is that the result boost::function object then couldn't produce an ordinary function pointer to pass to the callback.

This, of course, cannot be done in a static language like C++. It requires on the fly generation of first-class functions. C++ simply can't do that. But, there are various interesting tricks you can pull to generate functions at compile time with templates in ways that can help with this problem, even if they can fully solve it.

I'm particularly pleased with my solution, which looked something like this:

This basically allows you to automatically generate a 'thunk' function, a normal non-member function that can be passed to the callback, that then calls another function and adds the contents of a global variable you specify as a template parameter. It doesn't fully solve the problem, but it partially solves it. And I think in this case it will do something pretty close to what HazyBlueDot wants.

This should work even if you have the global variable in question inside an anonymous namespace.

What are your favorite features in the upcoming C++0x standard?

My personal favorites are:

• rvalue references - I once said that the STL containers should be defined to move things around with the swap operation instead of by using the copy constructor so that auto_ptr would work. My opinion is vindicated by rvalue references and the requirement that the STL containers use move construction.
• Variadic templates - So much stupid ugliness in Boost is because you can't have templates with variable numbers of arguments. This fixes that.

I wanted to have a fairly robust callback that would call something that might disappear before the callback is triggered. I wanted the callback to simply go dead when its target disappeared.

I thought about it a lot, and I came up with this:

This results in a lot of overhead per call though. More than I was expecting. And the other problem is that callback functions are limited to functions with a certain signature. You could use boost::bind to bind all the arguments to your callback and store them away safely so it looked like it was void (void), but that seems inelegant and like it wouldn't work well for some situations.

It's pretty easy to do f(g(x)) in boost, but not so easy to do f(g)(x) when f is something that creates a function that largely just needs to pass things along to g.

Is there a way around this?

#include <assert.h>

class Blah
{
public:
  const unsigned int &myfoo;
  Blah(const unsigned int &p):
    myfoo(p) {}
  const unsigned int getfoo()
  {
    return myfoo;
  }
};

int main()
{
  int foo(42);
  Blah baz(foo);

  ++foo;

  assert(foo == baz.getfoo());

  return 0;
}

( Here's how I did it...Collapse )

I was surprised by the output of this code using MSVC++ 6:

I expected the output to be 1 2 3 2 2 2; it was 1 2 3 2 3 3. Since id() is not virtual in t2, how can it be overridden in i5, and especially in i6?
This makes so little sense to me, I’m wondering if it’s a compiler error. Does anyone know?