# Converting constructor

> C++ Atlas: `cppatlas.com/w/cpp/language/converting_constructor` | Source: https://en.cppreference.com/w/cpp/language/converting_constructor | Domain: Language | Standards: C++11

A constructor that is not declared with the specifier explicit and which can be called with a single parameter(until C++11) is called a converting constructor.

## Official Specification Summary (cppreference)

A constructor that is not declared with the specifier explicit and which can be called with a single parameter (until C++11) is called a *converting constructor*.

Unlike explicit constructors, which are only considered during direct initialization (which includes explicit conversions such as static_cast), converting constructors are also considered during copy initialization, as part of user-defined conversion sequence.

It is said that a converting constructor specifies an implicit conversion from the types of its arguments (if any) to the type of its class. Note that non-explicit user-defined conversion function also specifies an implicit conversion.

Implicitly-declared and user-defined non-explicit copy constructors and move constructors are converting constructors.

### Example

```cpp
struct A
{
    A() { }         // converting constructor (since C++11)
    A(int) { }      // converting constructor
    A(int, int) { } // converting constructor (since C++11)
};

struct B
{
    explicit B() { }
    explicit B(int) { }
    explicit B(int, int) { }
};

int main()
{
    A a1 = 1;      // OK: copy-initialization selects A::A(int)
    A a2(2);       // OK: direct-initialization selects A::A(int)
    A a3{4, 5};    // OK: direct-list-initialization selects A::A(int, int)
    A a4 = {4, 5}; // OK: copy-list-initialization selects A::A(int, int)
    A a5 = (A)1;   // OK: explicit cast performs static_cast, direct-initialization

//  B b1 = 1;      // error: copy-initialization does not consider B::B(int)
    B b2(2);       // OK: direct-initialization selects B::B(int)
    B b3{4, 5};    // OK: direct-list-initialization selects B::B(int, int)
//  B b4 = {4, 5}; // error: copy-list-initialization selected an explicit constructor
                   //        B::B(int, int)
    B b5 = (B)1;   // OK: explicit cast performs static_cast, direct-initialization
    B b6;          // OK, default-initialization
    B b7{};        // OK, direct-list-initialization
//  B b8 = {};     // error: copy-list-initialization selected an explicit constructor
                   //        B::B()

    [](...){}(a1, a4, a4, a5, b5); // may suppress "unused variable" warnings
}
```

### See also

- [copy assignment](https://en.cppreference.com/w/cpp/language/as_operator)
- [copy constructor](https://en.cppreference.com/w/cpp/language/copy_constructor)
- [copy elision](https://en.cppreference.com/w/cpp/language/copy_elision)
- [default constructor](https://en.cppreference.com/w/cpp/language/default_constructor)
- [destructor](https://en.cppreference.com/w/cpp/language/destructor)
- [`explicit`](https://en.cppreference.com/w/cpp/language/explicit)
- [initialization](https://en.cppreference.com/w/cpp/language/initialization)
  - [aggregate initialization](https://en.cppreference.com/w/cpp/language/aggregate_initialization)
  - [constant initialization](https://en.cppreference.com/w/cpp/language/constant_initialization)
  - [copy initialization](https://en.cppreference.com/w/cpp/language/copy_initialization)
  - [default initialization](https://en.cppreference.com/w/cpp/language/default_initialization)
  - [direct initialization](https://en.cppreference.com/w/cpp/language/direct_initialization)
  - [initializer list](https://en.cppreference.com/w/cpp/language/initializer_list)
  - [list initialization](https://en.cppreference.com/w/cpp/language/list_initialization)
  - [reference initialization](https://en.cppreference.com/w/cpp/language/reference_initialization)
  - [value initialization](https://en.cppreference.com/w/cpp/language/value_initialization)
  - [zero initialization](https://en.cppreference.com/w/cpp/language/zero_initialization)
- [move assignment](https://en.cppreference.com/w/cpp/language/move_assignment)
- [move constructor](https://en.cppreference.com/w/cpp/language/move_constructor)
- [new](https://en.cppreference.com/w/cpp/language/new)

---
Attribution: content from https://en.cppreference.com/w/cpp/language/converting_constructor (cppreference.com), licensed under CC-BY-SA 3.0 and GFDL. Modified: converted to markdown, study notes added. Offline snapshot of 9 February 2025.