User Defined Conversions

In this lesson, we'll learn how to 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:

1#include <iostream>
2
3int main() {
4  int IntA{5};
5  if (IntA) {
6    std::cout << "IntA converted to true";
7  }
8
9  int IntB{0};
10  if (!IntB) {
11    std::cout << "\nIntB converted to false";
12  }
13}

1IntA converted to true
2IntB converted to false

Overloading Typecast Operators

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

As with any operator, we can overload them within our types. This allows us to define the process whereby one of our objects can be converted to a different type.

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 components
9  // of the vector are truthy
10  operator bool() const {
11    return x && y && z;
12  }
13};
14
15int main() {
16  Vector A { 1, 2, 3 };
17  Vector B { 0, 0, 0 };
18
19  // We can now treat Vectors as booleans
20  if (A) {
21    std::cout << "A is Truthy";
22  }
23
24  if (B) {
25    std::cout << "B is Truthy";
26  }
27}

1A is Truthy
2B is Falsy

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

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

Converting Constructors

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

Below, Move() expected a Vector. We pass it a float and, because a Vector can be constructed from a float, the compiler allows this:

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}

This can often be undesirable. Did the developer 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 provided an appropriate constructor, the compiler will allow this 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:

Unchanged Code|Show
1struct Vector {/*...*/}
12
13void Move(Vector Direction) {
14  // ...
15}
16
17int main() {
18  Move(true);
19}

This is because a bool can be converted to a float, and the float can then 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};

Now, calling this constructor implicitly will throw an error. However, we can still call it explicitly:

Unchanged Code|Show
1struct Vector {/*...*/}
12
13void Move(Vector Direction) {
14  // ...
15}
16
17int main() {
18  // Implicit calls are prevented
19  Move(5.f);
20  Move(true);
21
22  // Explicit calls are permitted
23  Move(Vector(5.f));
24  Move(Vector(true));
25
26  // Explicit casts are permitted
27  Move(static_cast<Vector>(5.f));
28  Move(static_cast<Vector>(true));
29}

Marking Typecast Overloads as explicit

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

1struct MyType {
2  explicit operator int() {
3    return 1;
4  }
5};
6
7void HandleInt(int) {}
8
9int main() {
10  MyType Object;
11
12  // Implicit conversions are blocked
13  int A = Object;
14  HandleInt(Object);
15
16  // Explicit conversions are permitted
17  int B = int(Object);
18  HandleInt(int(Object));
19
20  // Explicit named casts also permitted
21  int C = static_cast<int>(Object);
22}

1struct MyType {
2  constexpr explicit operator bool() {
3    return true;
4  }
5};
6
7int main() {
8  MyType Object;
9
10  // Control flow
11  if (Object) {}
12  while (Object) {}
13
14  // Boolean Logic
15  !Object;
16  true || Object;
17
18  // Compile-time logic
19  // Requires operator bool() to be constexpr
20  static_assert(Object);
21  if constexpr (Object) {}
22}

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 ever to 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};

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:

Unchanged Code|Show
1struct Vector {/*...*/}
14
15void Move(Vector Direction) {
16  // ...
17}
18
19int main() {
20  // Not allowed
21  Move(Vector(true)); 
22}

1error: 'Vector::Vector(bool)': attempting to reference a deleted function

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}

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

1struct TypeB; // Forward Declaration
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}

1error C2440: 'initializing': cannot convert from 'TypeA' to 'TypeB'

As we covered in the previous section, we could also have done this by updating TypeB to delete the constructor that accepts TypeA as an argument:

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

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.

Summary

In this lesson, we explored user-defined conversions, including how to implement and control them. We examined both the power and potential pitfalls of implicit and explicit conversions, and how to use these features effectively.

Main Points Learned:

• Overloading typecast operators allows custom types to be converted into other types.
• Implicit conversions can introduce risks, which can be mitigated by using guardrails such as the explicit keyword.
• Constructors can also serve as a means for implicit conversions, but may lead to unintended consequences if not used carefully.
• Marking constructors and typecast operators as explicit prevents accidental implicit conversions, enhancing code safety.
• It's possible to delete specific conversions using the delete keyword to prevent certain types of conversions entirely.
• Special considerations for bool typecasts and their implicit conversion behavior in different contexts.

Free and Unlimited Access

Professional C++

Unlock the true power of C++ by mastering complex features, optimizing performance, and learning expert workflows used in professional development

View Course