c++显式说明符生成更安全的代码

我的例子:

class MyClass {
public:
    MyClass() = default;
    // copy constructor
    explicit MyClass(const MyClass& other) = default; 
    // conversion constructor
    explicit MyClass(int val) : val_(val) {}; // constructor that creates a MyClass object from an int.. in other words this 'converts' an int into a MyClass object
private:
    int val_;
};

void foo(MyClass n) {};
int main() {
    MyClass obj;
    MyClass obj2 = obj; // implicit use of the copy constructor - does not compile if the copy ctor is marked explicit
    MyClass obj3(obj); // explicit call to the copy ctr... always works
    foo(obj); // regular call to foo, copy ctor called
    foo(2); // implicit use of the conversion ctr - does not compile if the conversion ctor is marked explicit.
            // this automatic conversion could be risky/undesired in some cases.. therefore the need for the explicit keyword.
    return 0;
}

以1.为例:

struct Foo{};
struct Bar {
    explicit Bar(Foo){}    
};
int main() {
    Bar a {Foo{}}; // compiles
    Bar b = Foo{}; // error
}

a可以编译，因为它使用直接初始化，所以可以使用显式构造函数。b不编译，因为它使用拷贝初始化。

显式构造函数防止意外地执行隐式转换:

void oops (const Bar&) {
}
int main() {
    oops (Foo{});
}

从传入的Foo构造一个临时的Bar，并将其绑定到引用参数。这在很大程度上是对用户隐藏的，如果构造开销很大，或者您期望实参和形参是相同的对象，则可能会导致令人惊讶的结果。

从复制初始化的cppreference页面:

复制初始化比直接初始化更宽松:explicit构造函数不是转换构造函数，不考虑复制初始化。

所以你第一个问题的答案是"设计"。复制初始化只考虑隐式转换。

至于为什么要禁用隐式转换:它是在构造可能危险的对象时用作安全措施的，因此应该是显式的(在代码中可见)。

例如，假设std::unique_ptr<T>的T*的构造函数是隐式的。现在让我们看看一些(人为的)用户代码:

void forbulate(Foo * const myFoo) {
    myFoo->doStuff();
    lookAt(myFoo); // My Foo is amazing
    myFoo->doMoreStuff();
}

乍一看这很好。但你不知道的是，lookAt实际上有以下原型:

void lookAt(std::unique_ptr<Foo> yourFoo);

所以我们实际上是在无声地构造一个unique_ptr<Foo>来传递给lookAt。这意味着一些非常重要的事情:这个unique_ptr现在是myFoo， 的所有者，并将在破坏时杀死它。实际情况是:

void forbulate(Foo * const myFoo) {
    myFoo->doStuff(); // Fine
    lookAt(myFoo)  // Still fine
                 ; // myFoo is `delete`d !
    myFoo->doMoreStuff(); // Ouch, undefined behaviour from accessing a dead object
} // Sorry caller, I accidentally your Foo :(

注意，删除本身可能已经是UB了(例如，如果myFoo是自动实例的地址)。无论如何，这段看起来无害的代码实际上是一颗地雷。不要到处散布地雷，这就是为什么我们有explicit构造函数:在实际的unique_ptr规范中，代码甚至无法编译，你知道哪里出了问题。