> ## Documentation Index > Fetch the complete documentation index at: https://docs.syntblaze.com/llms.txt > Use this file to discover all available pages before exploring further. # C++ Converting Constructor A converting constructor is a constructor that enables implicit type conversion from its parameter type(s) to the class type. It allows the compiler to automatically initialize an object of the class when a value of the parameter type is provided in a context expecting the class type. When the compiler encounters an expression of type `T` where an object of class `C` is expected, it searches for a converting constructor in `C` that accepts `T`. If found, the compiler generates a user-defined conversion sequence. Under C++17's guaranteed copy elision (prvalue materialization rules), implicit conversions during copy-initialization (e.g., passing by value or returning by value) directly initialize the target object in place; the compiler does not create or destroy any intermediate temporary objects. ## Syntax and Mechanics A constructor functions as a converting constructor if it is not declared with the `explicit` specifier, or, starting in C++20, if it is declared with a conditionally explicit specifier that evaluates to `false` (`explicit(false)`). It is invoked during copy-initialization, pass-by-value function calls, and return-by-value statements. ```cpp theme={"dark"} class DataContainer { public: int size; // Converting constructor (implicit by default) DataContainer(int s) : size(s) {} // Converting constructor (C++20: explicit evaluates to false) explicit(false) DataContainer(const char* str) {} // Converting constructor (multiple parameters with default arguments) DataContainer(double d, int padding = 0) {} }; void processContainer(DataContainer c) {} int main() { // Copy-initialization: directly initializes c1 from int DataContainer c1 = 42; // Function argument: directly initializes the parameter from int processContainer(100); // Directly initializes c2 from const char* DataContainer c2 = "payload"; } ``` ## C++11 and Multi-Argument Converting Constructors Prior to C++11, only constructors callable with exactly one argument were considered converting constructors. Starting with C++11, constructors requiring multiple arguments also function as converting constructors when utilized with brace-enclosed initializer lists (copy-list-initialization). ```cpp theme={"dark"} class Point { public: int x, y; // Multi-argument converting constructor (C++11) Point(int x_val, int y_val) : x(x_val), y(y_val) {} }; void drawPoint(Point p) {} int main() { // Implicit conversion from initializer list to Point Point p1 = {10, 20}; // Implicit conversion during function call drawPoint({5, 15}); } ``` ## The `explicit` Specifier and C++20 `explicit(bool)` To suppress implicit conversions, a constructor must be declared with the `explicit` keyword. An explicit constructor restricts object creation to direct-initialization, direct-list-initialization, or explicit type casting (e.g., `static_cast`). C++20 introduced conditionally explicit constructors (`explicit(bool)`), which evaluate a boolean constant expression at compile time. This allows a constructor to act as a converting constructor only if specific type traits are satisfied. ```cpp theme={"dark"} #include #include template class StrictContainer { public: // Non-converting constructor (unconditionally explicit) explicit StrictContainer(int) {} // C++20: Conditionally explicit constructor // Acts as a converting constructor ONLY if double is implicitly convertible to T explicit(!std::is_convertible_v) StrictContainer(double) {} }; int main() { // StrictContainer c1 = 42; // COMPILER ERROR: StrictContainer(int) is explicit and excluded from copy-initialization. // StrictContainer(double) evaluates to explicit(true) because double cannot convert to std::string. StrictContainer c2(42); // OK: direct-initialization explicitly invokes StrictContainer(int). StrictContainer c3 = 42; // OK: StrictContainer(int) is explicit and excluded. HOWEVER, double is convertible to int, // so StrictContainer(double) evaluates to explicit(false) and acts as a converting constructor. // The int `42` undergoes a standard conversion to double to satisfy this constructor. } ``` ## Technical Constraints 1. **Single User-Defined Conversion:** The C++ standard allows only one user-defined conversion sequence per implicit conversion. The compiler will not chain multiple converting constructors or combine a converting constructor with a user-defined conversion operator to resolve a type mismatch. 2. **Ambiguity and Standard Conversions:** If multiple converting constructors can satisfy an implicit conversion via standard conversions of the same rank, the compiler will emit an ambiguous overload error. For example, passing an `int` to a class that has both a `Constructor(double)` and a `Constructor(float)` results in ambiguity. Both `int` to `double` and `int` to `float` are standard floating-integral conversions of equal rank. The compiler cannot determine a best viable function, unlike with standard promotions (e.g., `short` to `int`), which have a higher rank and are used to actively resolve overload ambiguities.

Tired of Poor C++ Skills? Fix That With Deep Grasping! Learn More