explicit 显示构造

在 C++ 中，explicit 关键字用于修饰构造函数，以防止隐式类型转换。使用 explicit 关键字可以提高代码的可读性和安全性，避免意外的类型转换和构造函数调用。以下是使用 explicit 关键字的一些好处及示例：

好处

1. 防止隐式转换：

• 默认情况下，C++
  允许单参数构造函数（多参数构造函数不会隐式转换，多参数不必加explicit也是显示构造）用于隐式类型转换，这可能导致意想不到的结果。使用
  explicit 可以防止这种情况。

2. 提高代码可读性：

• 通过强制要求显式构造，可以使代码更加清晰，表明构造函数调用是有意为之，而不是通过隐式转换偶然发生的。

3. 减少错误：

• 隐式转换有时会导致难以发现的错误，特别是在重载函数和模板函数的情况下。使用 explicit 可以减少此类错误的发生。

示例

没有 explicit 关键字

#include <iostream>

class OutputSample {
public:
    OutputSample(int value) : m_value(value) {}

    int getValue() const { return m_value; }

private:
    int m_value;
};

void processSample(const OutputSample& sample) {
    std::cout << "Processing sample with value: " << sample.getValue() << std::endl;
}

int main() {
    OutputSample sample = 42; // 隐式转换
    processSample(42); // 隐式转换

    return 0;
}

在这个例子中，OutputSample 类的构造函数没有使用 explicit 关键字，因此编译器允许从 int 到 OutputSample 的隐式转换。这可能导致意想不到的结果。

使用 explicit 关键字

#include <iostream>

class OutputSample {
public:
    explicit OutputSample(int value) : m_value(value) {}

    int getValue() const { return m_value; }

private:
    int m_value;
};

void processSample(const OutputSample& sample) {
    std::cout << "Processing sample with value: " << sample.getValue() << std::endl;
}

int main() {
    // OutputSample sample = 42; // 错误：隐式转换被禁止
    OutputSample sample(42); // 正确：显式构造
    // processSample(42); // 错误：隐式转换被禁止
    processSample(OutputSample(42)); // 正确：显式构造

    return 0;
}

在这个例子中，OutputSample 类的构造函数使用了 explicit 关键字，从而禁止了从 int 到 OutputSample 的隐式转换。这样可以确保 OutputSample 对象的构造是有意为之，避免意外的类型转换。

如果一个类的构造函数有多个参数或者它没有单参数的构造函数，那么隐式转换就不会发生。隐式转换的前提是构造函数能够接受单个参数并且没有被 explicit 修饰。

多参数构造函数的情况

对于多参数构造函数，编译器无法进行隐式转换，因为它不知道该如何自动匹配多个参数。因此，必须显式地调用构造函数。

示例

1. 多参数构造函数

#include <iostream>

class MultiParameter {
public:
    MultiParameter(int x, int y) : m_x(x), m_y(y) {}

    void display() const {
        std::cout << "x: " << m_x << ", y: " << m_y << std::endl;
    }

private:
    int m_x;
    int m_y;
};

int main() {
    // MultiParameter obj = {1, 2}; // 错误：无法进行隐式转换
    MultiParameter obj(1, 2); // 正确：显式构造
    obj.display();

    return 0;
}

在这个例子中，由于 MultiParameter 类的构造函数有两个参数，因此无法进行隐式转换，必须显式地调用构造函数。

2. 单参数非显式构造函数与其他构造函数的共存

如果类中有一个单参数的非 explicit 构造函数以及其他多参数构造函数，那么只有单参数的非 explicit 构造函数可以进行隐式转换。

• #include

  class MixedConstructor { public:
  MixedConstructor(int x) : m_x(x), m_y(0) {
  std::cout << “Single parameter constructor called” << std::endl;
  }

  MixedConstructor(int x, int y) : m_x(x), m_y(y) {
      std::cout << "Two parameter constructor called" << std::endl;
  }
  
  void display() const {
      std::cout << "x: " << m_x << ", y: " << m_y << std::endl;
  }
  

  private:
  int m_x;
  int m_y; };

  int main() {
  MixedConstructor obj1 = 5; // 隐式转换，调用单参数构造函数
  obj1.display();

  MixedConstructor obj2(3, 4); // 显式调用两参数构造函数
  obj2.display();
  
  return 0; }
  

在这个例子中，由于 MixedConstructor 类有一个单参数的非 explicit 构造函数，因此 MixedConstructor obj1 = 5; 会进行隐式转换并调用单参数构造函数。而MixedConstructor obj2(3, 4); 则显式调用了两个参数的构造函数。

总结

使用 explicit 关键字可以防止隐式类型转换，提高代码的可读性和安全性，减少潜在的错误。通过明确的构造函数调用，可以更好地控制对象的创建和类型转换过程。

• **隐式转换：**如果类的单参数构造函数没有被 explicit 修饰，则可以使用单参数值直接给类对象赋值，编译器会进行隐式转换。

• **显式转换：**如果类的单参数构造函数被 explicit 修饰，则隐式转换将被禁止，必须使用显式的构造方法。

• 如果类只有一个单参数的非 explicit 构造函数，则可以进行隐式转换。

• 如果类有多个参数的构造函数，则必须显式调用构造函数，不能进行隐式转换。

• 如果类同时有单参数的非 explicit 构造函数和多参数构造函数，只有单参数的非 explicit
  构造函数可以进行隐式转换，多参数的构造函数仍需显式调用。