User Defined Conversions in C++

In this lesson, we'll learn how we can overload typecast operators from within our classes, allowing objects of our custom types to be converted to other types.

We'll also learn some dangers of enabling these implicit conversions, and the guardrails we can apply to eliminate the biggest risks.

Previously, we’ve seen how built-in types can be implicitly converted into other built-in types. For example, we can use an int where a bool is expected, and the compiler will convert the type for us:

1int MyInt { 5 };
2if (MyInt) {
3  // This code will run, because non-zero integers are truthy
4}
5

Overloading Typecast Operators

These conversions are done by specific types of operators, called typecast operators.

As with any operators, we can overload them within our own types. This gives us the ability to allow our own custom classes to define how their objects are converted into other types.

For example, if we wanted to allow our Vector objects to be convertible to booleans, it might look like this:

1#include <iostream>
2
3struct Vector {
4  float x;
5  float y;
6  float z;
7  
8  // Return true if all of the component floats are truthy
9  operator bool() const {
10    return x && y && z;
11  }
12};
13
14// We can now treat Vector objects as booleans
15int main() {
16  Vector A { 1, 2, 3 };
17  Vector B { 0, 0, 0 };
18
19  if (A) {
20    std::cout << "A is Truthy";
21  }
22
23  if (B) {
24    std::cout << "B is Truthy";
25  }
26}
27

This program logs out only A is Truthy

Converting to Custom Types

We are not restricted to just converting to built-in types. We can overload typecast operators for any type, including custom types:

1#include <iostream>
2using namespace std;
3
4// Forward-declaring an incomplete type so
5// it can be used within the Party class
6class Character;
7
8class Party {
9public:
10  Party(const Character* Founder) : Leader { Founder } {
11    cout << "A party was created" << endl;
12  }
13
14  const Character* Leader;
15};
16
17class Character {
18public:
19  string Name;
20
21  // Allow a Character to be implicitly converted to a Party
22  operator Party() const {
23    return Party { this };
24  }
25};
26
27// This function only accepts parties - not characters
28void StartQuest(Party Party) {
29  cout << Party.Leader->Name
30       << "'s party has started the quest";
31}
32
33int main() {
34  Character Player { "Frodo" };
35  // Because Characters can now be implicitly converted to parties
36  // we can pass a Character argument into a Party parameter
37  StartQuest(&Player);
38}
39

1A party was created
2Frodo's party has started the quest
3

Converting Constructors

Constructors can also be used for implementing conversions. By default, if an appropriate constructor is available, C++ will use it for implicit conversion:

1struct Vector {
2  Vector(float ComponentSize) :
3    x { ComponentSize },
4    y { ComponentSize },
5    z { ComponentSize } {}
6
7  float x;
8  float y;
9  float z;
10};
11
12void Move(Vector Direction) {
13  // ...
14}
15
16int main() {
17  Move(5.f);
18}
19

This can often be undesirable. Did the developer really intend to create a Vector on the highlighted line, or are they just misunderstanding the Move function? If the misunderstanding is the most likely explanation, we'd rather have the compiler throw an error here.

But, given we have overloaded an appropriate typecast operator, the compiler will allow this weird code, and we might have introduced a bug.

Worse, the implicit conversion can be done through an intermediate type. This will also compile without error or warning:

1Move(true);
2

This is because a boolean can be converted to a float, and then a float can be converted to a vector.

If a developer writes code like this, it is almost certainly a mistake on their part. We want the compiler to prevent it. Let's see how we can set that up.

Marking Constructors as explicit

To keep these conversions available, but prevent them from being called accidentally, we can mark them as explicit:

1struct Vector {
2  explicit Vector(float ComponentSize) :
3    x { ComponentSize },
4    y { ComponentSize },
5    z { ComponentSize } {}
6
7  float x;
8  float y;
9  float z;
10};
11

Now, lines 2 and 3 would throw an error. However, the conversion can still be done explicitly, as in lines 4 and 5:

1int main() {
2  Move(5.f);
3  Move(true);
4  Move(static_cast<Vector>(5.f));
5  Move(static_cast<Vector>(true));
6}
7

Marking Typecast Overloads as explicit

We can also mark overloaded typecast operators as explicit, to a similar effect:

1struct MyType {
2  explicit operator bool() const {
3    return true;
4  }
5};
6
7int main() {
8  MyType A;
9
10  // This is not allowed
11  if (A) {}
12
13  // This is fine
14  if (static_cast<bool>(A)) {}
15}
16

Removing Constructors with delete

Sometimes, we don’t want a conversion to be possible at all, even explicitly. For example, the ability to create a Vector from a boolean, by first converting the boolean to a float, is unlikely to ever be used intentionally.

We can’t envision any legitimate reason to do that - it would only seem like a misunderstanding on the part of the developer.

For scenarios like this, we can delete the constructor:

1struct Vector {
2  Vector(bool) = delete;
3
4  explicit Vector(float ComponentSize) :
5    x { ComponentSize },
6    y { ComponentSize },
7    z { ComponentSize } {}
8
9  float x;
10  float y;
11  float z;
12};
13

Now, anyone trying to create our object by passing in a bool, even explicitly, will have an error thrown rather than their misunderstanding causing a bug:

1// Not allowed
2Move(static_cast<Vector>(true));
3

Removing Typecast Overloads with delete

Similarly, we may want to delete specific typecast overloads. For example, we may have a type that we want to be convertible to a boolean. But, in so doing, we may also have made it convertible to other, unintended types:

1struct TypeA {
2  operator bool() {
3    return true;
4  }
5};
6
7struct TypeB {
8  TypeB(bool) {};
9};
10
11int main() {
12  TypeA ObjectA;
13
14  // This is allowed
15  if (ObjectA) {};
16
17  // This is also allowed, but it doesn't make sense
18  // We want the compiler to prevent this conversion
19  TypeB ObjectB { ObjectA };
20}
21

We can address this by deleting the typecast overload from TypeA:

1struct TypeB;
2
3struct TypeA {
4  operator bool() {
5    return true;
6  }
7
8  operator TypeB() = delete;
9};
10
11struct TypeB {
12  TypeB(bool) {};
13};
14
15int main() {
16  TypeA ObjectA;
17  
18  // This is still allowed
19  if (ObjectA) {};
20
21  // This is now prevented
22  TypeB ObjectB { ObjectA };
23}
24

Note, we could also have done this by updating TypeB to delete the constructor:

1struct TypeB {
2  TypeB(TypeA) = delete;
3  TypeB(bool) {};
4};
5

But, in practice, we are often working with types that we cannot, or cannot easily, modify. These can include internal types, or types we import from a library. Therefore, knowing how to control the conversion process from either side is a useful skill.