explicit Keyword in C++

I. Introduction
A. Brief overview of the explicit keyword

II. What is the explicit keyword in C++?
A. Definition of the explicit keyword

III. Examples of using explicit keyword
A. Example : Preventing Implicit Conversions

IV. Best Practices for using explicit keyword
A. When to use explicit keyword
B. When not to use explicit keyword
C. Code style guidelines

I. Introduction

One of the critical features of C++ is its ability to perform automatic type conversions. While type conversions can be convenient, they can also lead to unintended behavior that can be difficult to debug. This is where the explicit keyword in C++ comes in handy.

A. Brief overview of the explicit keyword

In C++, the explicit keyword is used to restrict the compiler from performing implicit type conversions. This means that the compiler will not automatically convert one type to another unless programmer instructed to do so. The explicit keyword can be applied to constructors, conversion operators, and single-argument functions.

II. What is the explicit keyword in C++?

A. Definition of the explicit keyword

In C++, the explicit keyword is used to prevent implicit conversions of types. When a constructor or a conversion function is marked explicit, the compiler will not use that constructor or function for implicit conversions. This means that the constructor or function must be explicitly called by the programmer.

 

Here is an example of an explicit constructor:

class Foo {
public:
    explicit Foo(int value) : m_value(value) {}
private:
    int m_value;
};

int main() {
    Foo f1 = 42; // Error: implicit conversion not allowed
    Foo f2(42);  // OK: explicit constructor call
    return 0;
}

In the above example, the Foo constructor takes an integer value and is marked explicit. This means that it cannot be used for implicit conversions. The first line of the main function attempts to create a Foo object from an integer value using implicit conversion, but it fails to compile because the constructor is marked explicit. The second line explicitly calls the Foo constructor with the integer value, and it compiles successfully.

III. Examples of using explicit keyword

A. Example : Preventing Implicit Conversions

One of the most common uses of the explicit keyword is to prevent implicit conversions. When a constructor has only one argument, it can be called implicitly to convert the argument into an object of the class type. However, this behavior can lead to unexpected results and potential bugs in the code.

 

Let's take a look at an example:

class Rectangle {
public:
    Rectangle(int width=0, int height=0) : width_{ width }, height_{ height } {
        std::cout << "Rectangle(int, int)" << std::endl
            << "width: " << width_ << ", height: " << height_ << ", Area: " << width_ * height_;
    }

private:
    int width_;
    int height_;
};

int main() {
    Rectangle rect = 10;
    return 0;
}

• In this example, we have a Rectangle class with a constructor that takes two arguments: width and height.
• In the main function, we create a Rectangle object rect with a width of 10 and height of 0, since we are passing only one argument to the constructor. This is because the constructor of Rectangle can be called implicitly.
• When we call the Consturcter, we get an unexpected result of 0 as the area. This is because the rect object has a height of 0, which was not intended.
• To prevent this kind of unexpected behavior, we can mark the constructor of Rectangle as explicit.

IV. Best Practices for Using Explicit Keyword

A. When to Use Explicit Keyword

The explicit keyword should be used in situations where you want to prevent implicit conversions, provide better control of object initialization, or avoid ambiguous function calls. Here are some specific scenarios where using the explicit keyword can be beneficial:

1. Constructors with a single argument If you have a constructor with a single argument, using the explicit keyword can prevent unintended implicit conversions. For example, consider the following code:

class MyClass {
public:
    MyClass(int x) {}
};

void func(MyClass obj) {}

int main() {
    func(42);
}

In this case, the integer value 42 is implicitly converted to a MyClass object when passed to the func() function. However, this may not be what was intended, and can lead to unexpected behavior. By marking the constructor with the explicit keyword, this implicit conversion can be prevented:

class MyClass {
public:
    explicit MyClass(int x) {}
};

void func(MyClass obj) {}

int main() {
    func(42); // Error: no matching function for call to 'func(int)'
    MyClass obj(42); // OK: explicitly constructs a MyClass object
}

1. Conversions between related types If you have a conversion function that converts between two related types, using the explicit keyword can prevent unintended implicit conversions. For example, consider the following code:

class MyClass {
public:
    operator int() const { return 42; }
};

int main() {
    MyClass obj;
    int x = obj;
}

In this case, the MyClass object is implicitly converted to an integer when assigned to the variable x. However, this may not be what was intended, and can lead to unexpected behavior. By marking the conversion function with the explicit keyword, this implicit conversion can be prevented:

class MyClass {
public:
    explicit operator int() const { return 42; }
};

int main() {
    MyClass obj;
    int x = static_cast<int>(obj); // OK: explicitly converts a MyClass object to an integer
}

1. Template functions If you have a template function that takes a type as a template parameter, using the explicit keyword can prevent unintended implicit conversions. For example, consider the following code:

Using the explicit keyword in these scenarios can help prevent unexpected behavior and make the code more explicit and easier to understand.

B. When not to use explicit keyword

While explicit keyword is a useful tool in preventing unwanted implicit conversions and improving code clarity, it should not be used in all cases. Here are some scenarios where using explicit keyword may not be the best choice:

1. When the conversion is cheap and unambiguous: If a conversion between types is cheap and unambiguous, it might be better to rely on the implicit conversion. Using explicit keyword in such cases would only add unnecessary code bloat and reduce readability.

// Example of a cheap and unambiguous conversion
class Feet {
public:
    Feet(double feet) : m_feet(feet) {}
    operator double() const { return m_feet; }
private:
    double m_feet;
};

double distance = 5.2;
Feet feet = distance; // Implicit conversion from double to Feet

1. When using a constructor as a conversion function: Constructors can be used as conversion functions, and in such cases, using explicit keyword would not make sense. For example, consider the following code:

class A {
public:
    A(int x) : m_x(x) {}
private:
    int m_x;
};

class B {
public:
    B(A a) : m_x(a) {}
private:
    A m_x;
};

A a(42);
B b = a; // Implicit conversion from A to B

In the above example, constructor of class B takes an object of class A as its argument. However, it can also be used to convert an object of class A to an object of class B. Using explicit keyword here would make the code less readable and add unnecessary complexity.

1. When there is a risk of slicing: If a class hierarchy involves inheritance and polymorphism, using explicit keyword might cause slicing if the derived object is passed as an argument to the base class constructor. In such cases, it is better to use implicit conversion to allow polymorphism.

class Base {
public:
    Base(int x) : m_x(x) {}
protected:
    int m_x;
};

class Derived : public Base {
public:
    Derived(int x, int y) : Base(x), m_y(y) {}
private:
    int m_y;
};

void foo(Base b) {
    // Do something with b
}

Derived d(42, 100);
foo(d); // Implicit conversion from Derived to Base

In the above example, if foo function took a Base object by reference or pointer, it would allow polymorphism and prevent slicing. Using explicit keyword here would prevent implicit conversion and introduce slicing.

 

In conclusion, explicit keyword is a powerful tool that can improve code clarity and prevent unwanted implicit conversions. However, it should be used judiciously and only in cases where it improves code readability and maintainability.

C. Code Style Guidelines

When using the explicit keyword in C++, it's important to follow consistent code style guidelines to ensure that the code is readable and maintainable. Here are some best practices to consider when using the explicit keyword:

1. Use the explicit keyword only when necessary: As mentioned earlier, the explicit keyword should only be used when it's necessary to prevent implicit conversions or when you need better control over object initialization. Overusing explicit can make the code more verbose and harder to read.
2. Use the explicit keyword on single-argument constructors: In most cases, the explicit keyword should be used on single-argument constructors. However, there are some cases where it may not be necessary or even desirable.
3. Be consistent in your use of the explicit keyword: If you decide to use the explicit keyword, be consistent in your use of it throughout your codebase. Inconsistencies in usage can lead to confusion and make the code harder to understand.