CNullable<T> : A convenient Nullable<T> equivalent class for C++/CLI

• Download source - 1.1 Kb

Overview

Starting with Whidbey, C# supports nullable types (value types that can also be null) and it does this using the

System::Nullable<T>
generic

System.Nullable<T> 
var

int? q1 = null;

if (q1.HasValue)
    Console.WriteLine(q1.Value);
else
    Console.WriteLine("It's null");    

q1 = 99;
q1++;

int? q2 = q1;
if (q2 != null)
{
    q2 = null;
}

Now, take a look at the corresponding C++ code (C# code in comments) :-

//int? q1 = null;
Nullable<int> q1;

//if (q1.HasValue)
//    Console.WriteLine(q1.Value);
//else
//    Console.WriteLine("It's null");

if(q1.HasValue)
    Console::WriteLine(q1.Value);
else
    Console::WriteLine("It's null");

//q1 = 99;

q1 = Nullable<int>(99);

//q1++;

if(q1.HasValue)
    q1 = Nullable<int>(q1.Value + 1);

//int? q2 = q1;

Nullable<int> q2 = q1;

//if (q2 != null)
//{
//    q2 = null;
//}

if( q2.HasValue )
{
    q2 = Nullable<int>();
}

Not very convenient, is it? Now look at this C++ code :-

//int? q1 = null;
CNullable<int> q1;

//if (q1.HasValue)
//    Console.WriteLine(q1.Value);
//else
//    Console.WriteLine("It's null");

if(q1.HasValue)
    Console::WriteLine(q1.Value);
else
    Console::WriteLine("It's null");

//q1 = 99;

q1 = 99;

//q1++;

(*q1)++;

////int? q2 = q1;

CNullable<int> q2 = q1;

//if (q2 != null)
//{
//    q2 = null;
//}

if(q2 != nullptr)
{
    q2 = nullptr;
}

Well, that's a lot more closer to the C# code as far as ease-of-use is concerned, is it not? That's why I wrote my

CNullable<> 
template ref

Class Reference

MC++

template<typename T> ref class CodeProject::Extra::CNullable sealed : 
INullableValue

CNullable can be used to represent a value type (or simple native type) such that the type can be nulled. You can also compare it to nullptr using the == and != operators both of which have been overloaded.

Constructors

• CNullable()

  The default constructor creates a CNullable object assigned to nullptr.

  MC++

  CNullable<char> x1;

• CNullable(void* p)

  This overload handles the case where a nullptr is passed to the constructor. If the pointer passed is not a

  MC++

  nullptr
  

  , an InvalidOperationException gets thrown.
  MC++

  CNullable<double> x2(nullptr);

• CNullable(const T% t)

  Constructs a CNullable object using the passed in template-argument type.

  MC++

  CNullable<int> x3(100);

• CNullable(const CNullable% n)

  Copy constructor.

  MC++

  CNullable<int> x4(x3);

Operators

• operator T()

  Converts to type T.

  Note - If the object is currently nulled, an

  MC++

  InvalidOperationException
  

  is thrown.
  MC++

  int y = x4;

• void operator =(void* p)

  Assignment operator that handles the

  MC++

  nullptr
  

  case.

  Note - If

  MC++

  p
  

  is a non-null pointer, an
  MC++

  InvalidOperationException
  

  is thrown.
  MC++

  x3 = nullptr;

• const T operator =(const T% t)

  Assignment operator for type T.

  MC++

  x4 = x3 = 13;

• T% operator*()

  The underlying type is exposed by overloading the dereference operator.

  MC++

  x5 = (*x4)++;

• bool operator ==(void* p)

  Allows

  MC++

  ==
  

  comparison with
  MC++

  nullptr
  

  .
  MC++

  if( x5 == nullptr )
  {
  }

• bool operator !=(void* p)

  Allows

  MC++

  !=
  

  comparison with
  MC++

  nullptr
  

  .
  MC++

  if( x5 != nullptr )
  {
  }

• operator String^()

  Gives the string representation of the type. Internally calls the

  MC++

  ToString
  

  method.
  MC++

  Console::WriteLine( (String^)x5 );

Methods

• virtual String^ ToString() override

  Returns an empty string if the object is currently nulled, else calls

  MC++

  ToString
  

  on the underlying template-argument type member and returns that string.
  MC++

  Console::WriteLine( x5.ToString() );

• Nullable<T> CreateNullable()

  Creates a new Nullable<T> object (useful to interact with .NET code that explicitly expects a Nullable<T>). Normally you'd be able to pass a CNullable object directly since it implements INullableValue.

  MC++

  Nullable<int> n1 = x5.CreateNullable();

• static CNullable^ FromNullable(Nullable<T> n)

  Static method to create a new CNullable object from a Nullable<T> object.

  MC++

  CNullable<int> x6 = CNullable<int>::FromNullable(n1);

Properties

• property virtual bool HasValue::get

  Implementation of INullableValue::HasValue. Indicates whether the value is valid or whether it's a null-value.

  MC++

  if(x6.HasValue)

• property virtual Object^ Value::get

  Implementation of INullableValue::Value. If

  MC++

  HasValue
  

  is true, it returns the value of the internal template argument type member, otherwise throws an
  MC++

  InvalidOperationException
  

  exception.
  MC++

  Console::WriteLine(x6.Value);

History

• May 18th, 2005 : Article first published on The Code Project.