C++无参及多参构造函数为何需声明为explicit？

Great question—you’re already ahead of the game grasping explicit for single-argument constructors, so let’s dive into these edge cases with clear, relatable examples.

1. Why mark a no-arg (default) constructor as explicit? #

At first glance, this might seem unnecessary—after all, a default constructor doesn’t convert from any value, right? The key here is preventing unintended implicit instantiation in contexts where the compiler might auto-create an instance without you explicitly asking for it.

Take this example:

class Logger {
public:
    Logger() { /* Initialize log file connection */ }
};

void process_log(const Logger& log) { /* ... */ }

Without explicit, you could accidentally write process_log({}) (using an empty initializer list) and the compiler would silently spin up a temporary Logger instance. This might be harmless here, but in complex code—like template functions or overloaded function sets—it can trigger unexpected overload resolution.

Suppose you also have:

void process_log(int log_level) { /* ... */ }

Now a call like process_log({}) becomes ambiguous: the empty list could convert to a Logger (via default constructor) or to an int (as 0). Marking the default constructor explicit:

explicit Logger() { /* ... */ }

forces you to write process_log(Logger{}) if you want the Logger version, eliminating ambiguity and making your intent crystal clear.

2. What’s the purpose of explicit for multi-arg constructors? #

This is all about blocking implicit conversions from initializer lists. Before C++11, explicit only mattered for single-arg constructors, but list initialization changed that—multi-arg constructors can now be used in implicit conversions too, unless you mark them explicit.

Let’s use a Point class as an example:

class Point {
public:
    Point(int x, int y) : x_(x), y_(y) {}
private:
    int x_, y_;
};

void draw(const Point& p) { /* ... */ }

Without explicit, you can call draw({3, 4}) and the compiler will implicitly turn the initializer list {3,4} into a Point instance. This looks convenient, but it can lead to subtle bugs when overloading functions.

Add another overload:

void draw(const std::vector<int>& coords) { /* ... */ }

Now draw({3,4}) could match either the Point constructor (since it takes two ints) or the vector constructor (since vectors accept initializer lists of ints). Which one gets picked? It depends on the compiler’s overload resolution rules, and it might not be what you intended.

Marking the multi-arg constructor explicit:

explicit Point(int x, int y) : x_(x), y_(y) {}

fixes this. Now draw({3,4}) will only match the vector overload, and to call the Point version you have to write draw(Point{3,4}) or draw(Point(3,4))—making your intent explicit and avoiding accidental conversions.

As a bonus, explicit also blocks copy-initialization syntax like Point p = {1,2};—you have to use direct initialization (Point p{1,2}; or Point p(1,2);), which many developers prefer for clarity.

内容的提问来源于stack exchange，提问作者kadina