C++/CLI nullptr incorrectly treated as "int" - c++-cli

Question

I am writing a managed wrapper in C++/CLI (VS2010) for a third-party unmanaged library. In the code, I have a method that looks like this:
if(oldState != _state && UnitStateChanged != nullptr)
UnitStateChanged(this, gcnew UnitStateChangedEventArgs(oldState, _state));
The "nullptr" generates the following error:
error C2446: '!=' : no conversion from 'int' to 'UnitStateChangedEventHandler ^'
The compiler seems to treat any use of "nullptr" as an "int", even on something as simple as this:
Object^ temp = nullptr;
Everything i've read indicates that the compiler will figure it out on it's own, but that doesn't seem to be the case. Is there a setting that I'm missing (other than /clr or #pragma managed)?

Answer 1

Someone without a C++11 compiler wrote
#define nullptr (0)
somewhere in a header file?
(The usual macro is #define NULL (0))
This is, of course, forbidden.

Answer 2

It looks like you're trying to fire an event.
In C#, there's a standard idiom for firing an event while protecting against null reference exceptions and multithreading modification:
// C#
EventHandler handler = this.MyEvent;
if(handler != null)
handler(this, new EventArgs(foo));
It looks like you're trying to re-create that in C++/CLI, but it's unnecessary. In C++/CLI, an event will emit three 'inner methods' (is that the proper name for them?) called add, remove, and raise. In C#, it creates add and remove only, no explicit raise, which is why we have to write that block of code over and over.
Here's an event defined in C++/CLI, and what .NET Reflector sees when it decompiles it:
// C++/CLI:
public ref class Test
{
public:
event EventHandler^ MyEvent;
};
// Decompiled to C#:
public class Test
{
// Fields
private EventHandler <backing_store>MyEvent;
// Events
public event EventHandler MyEvent
{
[MethodImpl(MethodImplOptions.Synchronized)] add
{
this.<backing_store>MyEvent = (EventHandler) Delegate.Combine(this.<backing_store>MyEvent, value);
}
[MethodImpl(MethodImplOptions.Synchronized)] remove
{
this.<backing_store>MyEvent = (EventHandler) Delegate.Remove(this.<backing_store>MyEvent, value);
}
raise
{
EventHandler <tmp> = null;
<tmp> = this.<backing_store>MyEvent;
if (<tmp> != null)
{
<tmp>(value0, value1);
}
}
}
}
The raise inner method is doing the null check for you, so you can skip doing it, and just fire the event without checking.
if(oldState != _state)
this->UnitStateChanged(this, gcnew UnitStateChangedEventArgs(oldState, _state));