目录
1. 隐式转换（Implicit Conversion）
2. 显式转换（Explicit Conversion）
3. 隐式转换的风险与显式转换的必要性
4. 隐式类型转换的例子
5. explicit 的作用
6. explicit 在构造函数中的作用
7. explicit 适用于转换操作符
- 隐式类型转换 发生在类的单参数构造函数和类型转换操作符被自动调用的情况下。
explicit的作用：阻止编译器进行隐式类型转换，要求调用者显式地进行类型转换或对象创建。- 使用场景：在类的单参数构造函数和类型转换操作符中，当隐式转换可能引发错误或误解时，使用
explicit关键字可以提高代码的可读性和安全性。
在说明explicit 的作用之前，我们先来搞清楚什么是隐式转换，什么是显示转换。
隐式转换和显式转换是两种类型转换方式，它们用于将一种类型的值转换为另一种类型。在编程语言中（如 C++、Java、Python 等），这两者的区别主要体现在转换的自动性和控制权上。
explicit 是 C++ 中的关键字，用于防止编译器在某些情况下进行隐式类型转换，尤其是在构造函数和类型转换操作符中。它可以显式声明构造函数或类型转换，避免潜在的意外行为，从而提高代码的安全性和可读性。
1. 隐式转换（Implicit Conversion）
隐式转换是由编译器自动执行的类型转换。通常，当需要将一个类型的值转换为兼容的另一种类型时，编译器会隐式地进行这种转换。它不需要显式的操作或用户的干预。
特点：
- 自动执行：不需要程序员明确地进行转换，编译器在适当的时候自动完成。
- 安全性：隐式转换通常在转换不会丢失数据或引起精度问题时发生。
- 简化代码：减少了类型转换的显式操作，使代码更加简洁。
常见的隐式转换：
- 整数到浮点数的转换。
- 窄类型到宽类型的转换，例如
int到double。 - 从派生类到基类的转换（向上转型）。
C++ 示例：
int a = 10;
double b = a; // 隐式转换：int 转换为 double在这个例子中，a 被隐式地转换为 double 类型赋值给 b。
Python 示例：
a = 10
b = a + 1.5 # 隐式转换：int 转换为 floata 在进行加法操作时，自动转换为 float 类型。
2. 显式转换（Explicit Conversion）
显式转换是由程序员手动指定的类型转换方式。程序员必须通过特定的语法，明确告诉编译器执行转换操作。这种转换通常用于转换不兼容的类型，或者当隐式转换可能会导致数据丢失时。
特点：
- 需要手动指定：程序员必须使用明确的语法进行类型转换。
- 安全性控制：显式转换通常用于需要精确控制转换过程，避免潜在的错误或数据丢失。
- 灵活性：可以进行更复杂和不安全的类型转换。
常见的显式转换方式：
- C++ 中的类型转换操作：如
static_cast、dynamic_cast、reinterpret_cast。 - C 风格的类型转换：如
(int)，(double)。 - Python 中的强制类型转换：如
int()，float()，str()。
C++ 示例：
double x = 9.7;
int y = static_cast<int>(x); // 显式转换：double 转换为 int，截断小数部分Python 示例：
x = 9.7
y = int(x) # 显式转换：float 转换为 int，截断小数部分在这两个示例中，x 被显式转换为 int，而转换后的小数部分会被舍弃。
隐式转换 vs 显式转换
3. 隐式转换的风险与显式转换的必要性
隐式转换虽然方便，但有时会引发意外的错误，特别是当类型不完全兼容时，可能会导致数据丢失或精度问题。这时候，显式转换就非常有用，可以确保程序员明确意识到可能的风险并加以控制。
风险示例：
double d = 9.99;
int i = d; // 隐式转换，数据丢失，i 变成 9这种情况下，小数部分被丢失。如果我们希望精确控制这种行为，应该使用显式转换：
int i = static_cast<int>(d); // 显式转换，确保数据截断是程序员预期的行为接下来我们再来说明explicit 的作用。
4. 隐式类型转换的例子
当一个类有一个带单参数的构造函数时，编译器会自动进行隐式类型转换，将参数类型转换为该类的对象。这种隐式转换有时会导致意想不到的结果。
示例：
#include <iostream>
class MyClass {
public:
// 构造函数，可以接受 int 类型
MyClass(int x) {
std::cout << "MyClass constructor called with " << x << std::endl;
}
};
void printObject(const MyClass& obj) {
std::cout << "Object received" << std::endl;
}
int main() {
MyClass obj = 42; // 隐式转换：int 转换为 MyClass 对象
printObject(42); // 隐式转换：int 被转换为 MyClass 对象
}在上面的代码中：
MyClass obj = 42;触发了隐式类型转换，编译器将42转换为MyClass对象。printObject(42);也触发了隐式类型转换，将42转换为MyClass对象。
虽然这种隐式转换看似方便，但在某些情况下可能会导致难以发现的错误或非预期的行为。
5. explicit 的作用
为防止不必要的隐式转换，可以在构造函数前加上 explicit 关键字。explicit 使得构造函数不能被隐式调用，只能通过显式地传递参数来调用。
示例：
#include <iostream>
class MyClass {
public:
// 使用 explicit 防止隐式类型转换
explicit MyClass(int x) {
std::cout << "MyClass constructor called with " << x << std::endl;
}
};
void printObject(const MyClass& obj) {
std::cout << "Object received" << std::endl;
}
int main() {
// MyClass obj = 42; // 错误！不能进行隐式类型转换
MyClass obj(42); // 必须显式调用构造函数
// printObject(42); // 错误！需要显式转换
printObject(MyClass(42)); // 必须显式地转换为 MyClass 对象
}在此例中，由于使用了 explicit，编译器不再允许隐式类型转换，必须通过显式地构造对象来使用 MyClass。
6. explicit 在构造函数中的作用
- 隐式转换：当一个类有一个带单参数的构造函数时，可以通过传递该类型的参数直接创建对象，而无需显式调用构造函数，这称为隐式类型转换。
- 使用
explicit：为构造函数添加explicit关键字可以阻止编译器执行隐式类型转换，要求调用者显式地进行类型转换。
代码对比：
-
没有
explicit：
class MyClass {
public:
MyClass(int x) {
// 构造函数
}
};
MyClass obj = 10; // 隐式转换-
没有
explicit：
class MyClass {
public:
explicit MyClass(int x) {
// 构造函数
}
};
MyClass obj(10); // 显式调用7. explicit 适用于转换操作符
除了构造函数外，explicit 也可以用于类型转换操作符，防止不合适的自动类型转换。
示例：
#include <iostream>
class MyClass {
public:
explicit operator int() const {
return 42;
}
};
int main() {
MyClass obj;
// int x = obj; // 错误！explicit 禁止隐式转换
int x = static_cast<int>(obj); // 正确，必须显式转换
std::cout << x << std::endl; // 输出 42
}此例中，operator int() 被声明为 explicit，因此不能隐式转换为 int，但可以通过 static_cast 显式转换。
