> ## 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++ Explicit Constructor An explicit constructor in C++ is a constructor declared with the `explicit` specifier to prevent the compiler from performing implicit type conversions and copy-initialization. By default, any constructor that can be called with a single argument acts as a converting constructor, allowing the compiler to automatically convert the argument type to the class type. The `explicit` keyword disables this behavior, strictly mandating direct-initialization or explicit casting. ```cpp theme={"dark"} class ClassName { public: // Syntax: Place the 'explicit' keyword before the constructor declaration explicit ClassName(Type parameter); }; ``` ## Mechanical Behavior When a constructor is marked `explicit`, it alters how the compiler resolves object initialization. C++ distinguishes between direct-initialization and copy-initialization. An explicit constructor is only viable during direct-initialization. * **Direct-initialization (Allowed):** Occurs when arguments are provided explicitly within parentheses `()` or braces `{}`. * **Copy-initialization (Blocked):** Occurs when an object is initialized using the equals sign `=`, passed by value to a function, or returned by value from a function. ```cpp theme={"dark"} class ImplicitData { public: // Non-explicit constructor (Converting constructor) ImplicitData(int x) {} }; class ExplicitData { public: // Explicit constructor explicit ExplicitData(double y) {} }; void processImplicit(ImplicitData d) {} void processExplicit(ExplicitData d) {} int main() { // --- Non-explicit behavior ImplicitData d1(10); // OK: Direct-initialization ImplicitData d2 = 10; // OK: Copy-initialization (Implicit conversion) processImplicit(10); // OK: Implicit conversion of int to ImplicitData // --- Explicit behavior ExplicitData d3(5.5); // OK: Direct-initialization // ExplicitData d4 = 5.5; // ERROR: Copy-initialization is blocked // processExplicit(5.5); // ERROR: Implicit conversion is blocked ExplicitData d5 = static_cast(5.5); // OK: Explicit cast forces conversion return 0; } ``` ## Multi-Argument Constructors (C++11 and later) Prior to C++11, the `explicit` specifier was only meaningful for constructors callable with a single argument. With the introduction of uniform initialization (brace initialization) in C++11, constructors with multiple arguments can also participate in implicit conversions via list-initialization. Applying `explicit` to a multi-argument constructor prevents implicit list-initialization. ```cpp theme={"dark"} class Point { public: explicit Point(int x, int y) {} }; void draw(Point p) {} int main() { Point p1{1, 2}; // OK: Direct-list-initialization // Point p2 = {1, 2}; // ERROR: Copy-list-initialization blocked // draw({1, 2}); // ERROR: Implicit list-initialization blocked return 0; } ``` ## Conditional `explicit` (C++20) C++20 introduced the conditionally explicit specifier, allowing the `explicit` keyword to take a boolean constant expression. This is primarily used in template metaprogramming to make a constructor explicit only if certain compile-time type traits are met. ```cpp theme={"dark"} #include template class Wrapper { public: // Constructor is explicit only if T is not an integral type explicit(!std::is_integral_v) Wrapper(T value) {} }; ```

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