# Explicit Constructor

An explicit constructor in C++ is a constructor declared with the `explicit` keyword. Its main purpose is to prevent implicit type conversions and copy-initialization. This helps avoid unintended conversions that might lead to subtle bugs or unexpected behavior.

```cpp
#include <iostream>
#include <string>

class MyString {
private:
    std::string str;

public:
    // Non-explicit constructor
    MyString(const char* s) : str(s) {
        std::cout << "Char* constructor called" << std::endl;
    }

    // Explicit constructor
    explicit MyString(int n) : str(n, 'a') {
        std::cout << "Integer constructor called" << std::endl;
    }

    void print() const {
        std::cout << str << std::endl;
    }
};

void takeMyString(const MyString& ms) {
    ms.print();
}

int main() {
    MyString s1 = "Hello";  // OK: Calls char* constructor
    s1.print();

    MyString s2(5);  // OK: Calls integer constructor
    s2.print();

    // MyString s3 = 5;  // Error: Implicit conversion not allowed
    MyString s4 = MyString(5);  // OK: Explicit conversion

    takeMyString("World");  // OK: Implicit conversion allowed
    // takeMyString(10);  // Error: Implicit conversion not allowed
    takeMyString(MyString(10));  // OK: Explicit conversion

    return 0;
}
```

> Run it [here](https://onecompiler.com/cpp/42kzzk52e).

Let's break down this example:

1. We have a `MyString` class with two constructors:
   * A non-explicit constructor that takes a `const char*`
   * An explicit constructor that takes an `int`
2. The non-explicit constructor allows implicit conversions:
   * `MyString s1 = "Hello";` works fine.
   * `takeMyString("World");` also works, implicitly converting the C-string to a `MyString`.
3. The explicit constructor prevents implicit conversions:
   * `MyString s2(5);` works as expected, calling the integer constructor.
   * `MyString s3 = 5;` would cause a compile-time error if uncommented.
   * `takeMyString(10);` would also cause an error if uncommented.
4. However, explicit conversions are still allowed:
   * `MyString s4 = MyString(5);` works fine.
   * `takeMyString(MyString(10));` is also valid.

Key points about explicit constructors:

1. They prevent implicit type conversions, reducing the risk of accidental conversions.
2. They're particularly useful for single-argument constructors to avoid unintended implicit conversions.
3. They can help catch potential errors at compile-time rather than runtime.
4. They don't prevent explicit conversions, so you can still perform the conversion when you really intend to.

Using `explicit` constructors is generally considered good practice for single-argument constructors unless you specifically want to allow implicit conversions. This can lead to more predictable and less error-prone code.


---

# Agent Instructions: Querying This Documentation

If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://notes.tejpratapsingh.com/_/cpp/code/classes/explicit-constructor.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.