C++ explicit关键字讲解

一、explicit关键字的定义

explicit 关键字被设计用来防止由编译器隐式执行的自动类型转换。当我们在类中声明构造函数时使用了关键字 explicit，编译器在初始化时不会自动转换参数类型，需要我们在构造函数中显式的进行转换。该关键字只能用于一个参数的构造函数，当构造函数需要多个参数时，不需要使用这个关键字，因为编译器无法进行多个类型的隐式转换。

例如，假设我们有以下类定义：

class Test{
public:
    Test(int value): num(value) {}
private:
    int num;
};

如果我们在创建这个类的对象时，使用了一个其他类型的值，比如一个字符串类型，会发生以下隐式类型转换：

Test t = "hello";

在上述代码中，虽然我们的构造函数声明中只有一个整型参数，但是编译器会自动将字符串转换为整数类型，然后传递给构造函数进行初始化。这种行为可能会导致我们在编码时出现错误。如果我们想保证类型的安全，应该使用 explicit 关键字将构造函数定义为显式转换构造函数，禁止编译器进行自动类型转换操作。

二、示例说明

接下来我们通过两个示例来说明explicit的使用方法和效果。

示例一

在这个示例中，我们创建了一个名为 Person 的类，其中有名为 Person(const std::string& name) 的构造函数。我们在这个构造函数前加上 explicit 关键字，从而禁止了编译器的隐式类型转换。

#include <iostream>
#include <string>

class Person {
public:
    explicit Person(const std::string& name) :m_Name(name) {}

    std::string getName() const {
        return m_Name;
    }

private:
    std::string m_Name;
};

void printPerson(const Person& person) {
    std::cout << person.getName() << std::endl;
}

int main() {
    // 正确做法：显式的转换类型
    Person person1 = Person(std::string("Mike"));
    printPerson(person1);

    // 错误做法：隐式的转换类型
    Person person2 = "John";
    printPerson(person2); // 编译报错

    return 0;
}

在上述代码中，我们定义了一个名为 Person 的类，这个类有一个名为 getName() 的函数，返回实例的名称。我们在 Person 的构造函数前加上了 explicit 关键字，从而禁止了编译器的隐式类型转换。在主函数中，我们显式地创建了一个 Person 的实例，然后调用 printPerson() 函数输出其名称。然后我们尝试使用隐式类型转换创建了另一个实例，从而使其编译失败。

示例二

在这个示例中，我们创建了一个名为 Book 的类，其中有一个名为 Book(float price) 的构造函数。然后我们定义了一个名为 printPrice() 的函数，用于输出书的价格。在主函数中，我们使用 explicit 关键字将之前的构造函数定义为显式构造函数，从而禁止了编译器的隐式类型转换。

#include <iostream>

class Book {
public:
    explicit Book(float price) :m_Price(price) {}

    float getPrice() const {
        return m_Price;
    }

private:
    float m_Price;
};

void printPrice(const Book& book) {
    std::cout << book.getPrice() << std::endl;
}

int main() {
    Book book1(10.0);
    printPrice(book1);

    Book book2 = Book(15.0);
    printPrice(book2);

    // 错误做法：隐式的转换类型
    //Book book3 = 20.0f;
    //printPrice(book3); // 编译报错

    // 正确做法：显式的转换类型
    Book book4 = Book(20.0f);
    printPrice(book4);

    return 0;
}

在上述代码中，我们定义了一个名为 Book 的类，这个类有一个名为 getPrice() 的函数，返回实例的价格。我们在 Book 的构造函数前加上了 explicit 关键字，从而禁止了编译器的隐式类型转换。在主函数中，我们先分别使用两种方式创建了两个 Book 实例，然后尝试使用隐式类型转换创建了第三个实例，从而使其编译失败。随后我们又使用了显式类型转换创建了第四个实例，从而成功输出了书的价格。