C++ Casting

Implicit conversion in C++ is when one type is converted to another without the need of a special operator. It looks automatic. When dealing with standard or built-in types, the compiler attempts conversions until it succeeds (with or without warnings) or fails (errors out).

When dealing with custom C++ Constructs, the programmer will need to define member functions to allow implicit conversion. Take the two data structures below. We have a struct called Quartet that is some generic container for 4 floats and a potentially meatier class called Rect.

// Tuple of 4 float values
struct Quartet { float a, b, c, d; };

// Blueprint for a Rectangle
class Rect
{
public:
    //etc etc
    float xUpperLeft, yUpperLeft;
    float xLowerRight, yLowerRight;
    float Area()
    {
        return 2 * ( (xLowerRight - xUpperLeft) + (yUpperLeft - yLowerRight) );
    }
    //etc etc
};

There are a few ways to enable implicit conversion.

Cast Operator

This will allow us to enable implicit conversion ‘‘to’’ another type.

class Rect
{
public:
    //etc etc
    operator Quartet()
    {
        Quartet q = Quartet();
        q.a = xUpperLeft; q.b = yUpperLeft; 
        q.c = xLowerRight; q.d = yLowerRight;
        return q;
    }
};

The method above could also just do return Quartet() and some other code could exist to define how values are set.

//Usage
Rect myRect;
Quartet myQuartet = myRect;

This is the use case where we’ve made a new Quartet using myRect’s values.

Assignment Operator

This will allow us to enable implicit conversion ‘‘from’’ another type but only via assignment.

// Blueprint for a Rectangle
class Rect
{
public:
    //etc etc
     Rect& operator= (const Quartet& q)
    {
        // xUpperLeft = q.a; etc etc
        return *this;
    }
};

Above, the assignment operator of Rect is set to be able to take in a Quartet constant reference, do some processing and return itself as a reference. Below is how you would use it.

Rect myRect;
Quartet myQuartet;
myRect = myQuartet;

With this method, you will not be able to construct/assign Rect in one expression i.e. Rect myRect = myQuartet will not compile. For that you will need:

Type Constructor

Another way to get implicit conversion ‘‘from’’ another type is to simply have a constructor with a single argument of that type.

class Rect
{
public:
    //etc etc    
    Rect(const Quartet& q)
    {
        // Initialize values here
    }
};

In the constructor, you can set Rect’s values with the incoming Quartet. The use case can only happen when you construct your Rect so it’s a little more rigid.

Quartet myQuartet;
Rect myRect = myQuartet;