With Visual C++ mixing managed and unmanaged code is always interesting. It either just works, or your application dies horribly before reaching the main entry point. Debugging in the pre-main world of static data registration and atexit handlers is not very fun. Fortunately a post made by Jeffrey Tan of Microsoft Online Community Support provides a solution:

By further discussing with a developer from VC++ team, he confirmed that
this was a known issue. The main problem here is that the IDE is specific
the entry of ManagedApp as “main”. However, using “main” will bypass a lot
of CRT’s startup initialization. The fix here is to simply change the
entry point in the IDE. Under ManagedApp -properties-link -advanced,
change “entry point” from “main” to
“?mainCRTStartupStrArray@@$$FYMHP$01AP$AAVString@System@@@Z”. That should
re-enable the CRT startup code which initializes the internal CRT variables.

Original discussion can be found here.

Recently I needed to update data in a base class, but only for types derived from that class.

struct Base {
	void Func() { cout << "Base::Func calledn"; }
};

struct Child : public Base { };

struct AnotherStruct { };

For example I want to call Base:Func() for all types that have been derived from Base. In the code above this would include Child and Base, but not AnotherStruct. If I've been given AnotherStruct then I don't want to do anything.

void call_base_func( Base* base ) {
	base->Func();
}

void call_base_func( void* ) { }

Thanks to function overloading this can be solved easily. Passing a Child to call_base_func will result in the first function being called, while AnotherStruct will use the second function.

But what do we do if Base is using the Curiously Recursive Template pattern?

template 
struct Base {
	void Func() { cout << "Base::Func calledn"; }
};

struct Child : public Base { };

struct AnotherStruct { };

Well now the type of Base is dependent on the type of Child. This breaks our previous solution as we can't specify Base without also specifying a type. Or can we?

template 
void call_base_func( Base* base ) {
	base->Func();
}

void call_base_func( void* ) { }

Sure we can. If Base is going to use templates, then so can call_base_func. As an added bonus we also get the type that initially derived from Base.

-

An example of this technique is with smart pointers. More specifically if you have a look a Boost shared_ptr it provides an enable_shared_from_this base class. This class tracks references to the derived object and allows you to acquire a corresponding shared_ptr to that object. The only way this can function is if the shared_ptr class can update the internal data in enable_shared_from_this, and only when the type is derived from enable_shared_from_this.

Recently I’ve been playing around with managed C++ and the .net framework. As usual I have one thread wanting to instruct a separate GUI thread to perform some task. In .net world with the help of delegates (glorified function pointers) this behaviour is easy.

First define the function to call:

///  update text box text from another thread
void MyGuiClass::updateText( System::String^ text ) {
	// show text
}

then define a delegate:

public delegate void GuiUpdateTextDelegate( );

and finally invoke the delegate from another thread:

BeginInvoke(
	gcnew GuiUpdateTextDelegate(
		this, &MyGuiClass::updateText, gcnew Systen::String("new text")
	)
);

While I’ve used BeginInvoke here, you should be aware that there is also an Invoke method. Invoke will wait until the delegate has been invoked, while BeginInvoke won’t and is asynchronous.