explicit

Keyword: explicit

In C++, the explicit keyword is used to prevent implicit conversions or copy-initialization that the compiler might otherwise perform. It's primarily applied to constructors and conversion operators to make your code safer and more predictable.

Basic Usage of explicit with Constructors

When you declare a constructor as explicit, you are telling the compiler not to allow that constructor to be used for implicit conversions.

Example Without explicit:

When you declare a constructor as explicit, you are telling the compiler not to allow that constructor to be used for implicit conversions.

Example 1: Use without explicit:

#include <iostream>

class MyClass {
public:
    MyClass(int x) {
        std::cout << "Constructor called with " << x << std::endl;
    }
};

void printMyClass(const MyClass& obj) {
    std::cout << "In printMyClass function" << std::endl;
}

int main() {
    MyClass obj = 42;  // Implicit conversion from int to MyClass
    printMyClass(100);  // Implicit conversion and then passing to function

    return 0;
}

Explanation:

• In the above code, the constructor MyClass(int x) is not marked as explicit.
• This allows implicit conversions, such as MyClass obj = 42;, where 42 is implicitly converted to a MyClass object.
• Similarly, printMyClass(100); allows an implicit conversion from int to MyClass when calling the function.

Example 2: with explicit:

#include <iostream>

class MyClass {
public:
    explicit MyClass(int x) {
        std::cout << "Constructor called with " << x << std::endl;
    }
};

void printMyClass(const MyClass& obj) {
    std::cout << "In printMyClass function" << std::endl;
}

int main() {
    // MyClass obj = 42;  // Error: Implicit conversion is not allowed
    MyClass obj(42);  // OK: Direct initialization is allowed
    // printMyClass(100);  // Error: Implicit conversion is not allowed
    printMyClass(MyClass(100));  // OK: Explicit conversion is required

    return 0;
}

Explanation:

• By marking the constructor MyClass(int x) as explicit, you prevent the compiler from using it for implicit conversions.
• MyClass obj = 42; would result in a compile-time error because the conversion from int to MyClass requires an explicit call to the constructor.
• printMyClass(100); is also an error because the conversion from int to MyClass is not allowed implicitly; you need to explicitly construct the object by writing printMyClass(MyClass(100));.

Why Use explicit?

• Preventing Unintended Conversions: Implicit conversions can sometimes lead to unexpected behavior or subtle bugs. By using explicit, you force the programmer to make the conversion intentional, reducing the likelihood of errors.
• Improving Code Clarity: When a constructor or conversion operator is marked as explicit, it makes the code's intention clearer to readers. It shows that certain operations require explicit acknowledgment from the programmer.

Example 3: Use with Conversion Operators

explicit can also be used with conversion operators to prevent implicit type conversions.

#include <iostream>

class MyClass {
public:
    explicit operator bool() const {
        return true;
    }
};

int main() {
    MyClass obj;
    // if (obj) {  // Error: Implicit conversion to bool is not allowed
    if (static_cast<bool>(obj)) {  // OK: Explicit conversion is required
        std::cout << "Object is true" << std::endl;
    }

    return 0;
}

Explanation

• The conversion operator operator bool() is marked as explicit, so if (obj) is not allowed.
• You must explicitly cast the object to bool using static_cast<bool>(obj) to perform the conversion.

Summary

• explicit Constructor: Prevents a constructor from being used for implicit conversions, requiring explicit calls instead.
  • Example: explicit MyClass(int x);
• explicit Conversion Operator: Prevents a conversion operator from being used implicitly, requiring an explicit cast.
  • Example: explicit operator bool() const;
• Purpose: explicit helps in preventing unintended conversions, improving code safety and clarity.

Using explicit is a good practice in cases where you want to avoid automatic type conversions that could lead to unexpected results or bugs in your code.