Explicit Keyword

The explicit keyword in C++ is used to prevent unintended implicit conversions. It can be applied to constructors and typecast operators to ensure that they are not called implicitly.

This enhances the safety and clarity of your code by making conversions explicit. Let's look at an example using a constructor:

1#include <iostream>
2
3class Vector {
4public:
5  float x, y, z;
6
7  // Explicit constructor
8  explicit Vector(float value)
9    : x(value), y(value), z(value) {}
10};
11
12void Move(Vector direction) {
13  std::cout << "Moving in direction: "
14    << direction.x << ", "
15    << direction.y << ", "
16    << direction.z;
17}
18
19int main() {
20  // This is allowed as we're explicitly
21  // constructing a Vector
22  Vector v1(1.0f);  
23
24  // This is also explicit, so is allowed
25  Move(Vector(1.0f));  
26
27  // This woul require an implicit conversion
28  // so it is not allowed
29  Move(1.0f); 
30}

1error: 'void Move(Vector)': cannot convert argument 1 from 'float' to 'Vector'
2note: Constructor for class 'Vector' is declared 'explicit'

In this example, the Vector constructor is marked as explicit, meaning you cannot pass a float directly to functions expecting a Vector without an explicit cast.

This prevents mistakes where a float might be mistakenly passed to a function expecting a Vector. Similarly, you can use explicit with typecast operators:

1class MyType {
2 public:
3  // Explicit typecast operator
4  explicit operator int() const { return 42; }
5};
6
7int main() {
8  MyType obj;
9
10  // Explicit conversion allowed
11  int A = static_cast<int>(obj); 
12
13  // Error: implicit conversion not allowed
14  int B = obj;  
15}

1error: 'initializing': cannot convert from 'MyType' to 'int'
2note: No user-defined-conversion operator available that can perform this conversion, or the operator cannot be called

Here, the explicit typecast operator prevents implicit conversion to int. You must use static_cast<int>(obj) to perform the conversion explicitly.

By using explicit, you can make your code more robust and easier to understand, as it avoids unintended conversions that could lead to subtle bugs.