Preventing Bool to Custom Type Conversion

To prevent a boolean from being converted to a custom type in C++, you can use the delete keyword to explicitly delete the constructor or typecast operator that would enable such a conversion.

This ensures that any attempt to perform the conversion results in a compilation error. Here's an example using a Vector class:

1#include <iostream>
2
3class Vector {
4 public:
5  float x, y, z;
6
7  // Constructor from float is allowed
8  explicit Vector(float value)
9    : x(value), y(value), z(value) {}
10
11  // Constructor from bool is deleted
12  Vector(bool) = delete;  
13};
14
15void Move(Vector direction) {
16  std::cout << "Moving in direction: "
17    << direction.x << ", "
18    << direction.y << ", "
19    << direction.z;
20}
21
22int main() {
23  Vector v1(1.0f);
24  Move(v1);
25
26  // Error: constructor is deleted
27  Vector v2(true);
28
29  // Error: constructor is deleted
30  Move(true);
31}

1error: attempting to reference a deleted function
2note: 'Vector::Vector(bool)': function was explicitly deleted

In this example, the Vector class has a constructor that accepts a float but explicitly deletes the constructor that accepts a bool. This prevents the creation of a Vector from a boolean value.

Another way to prevent unwanted conversions is by deleting the typecast operator that allows the conversion. For example:

1#include <iostream>
2
3class CustomType {
4 public:
5  // Allow conversion to int
6  explicit operator int() const { return 42; }
7
8  // Delete conversion to bool
9  operator bool() const = delete;  
10};
11
12int main() {
13  CustomType obj;
14
15  // Explicit conversion to int
16  int value = static_cast<int>(obj);
17  std::cout << "Value: " << value << "\n";
18
19  // Error: conversion to bool is deleted
20  bool flag = static_cast<bool>(obj); 
21}

1error: attempting to reference a deleted function
2note: 'CustomType::operator bool(void) const': function was explicitly deleted

In this example, the CustomType class allows conversion to int but deletes the conversion to bool. This ensures that a CustomType object cannot be used in a boolean context, preventing unintended or illogical conversions.

By deleting specific constructors or typecast operators, you can control how your custom types are used and ensure that only meaningful and intended conversions are allowed.

This enhances the robustness and clarity of your code, making it easier to maintain and less prone to errors.