Что означает ключевое слово explicit в C++? Когда и зачем его использовать?

Что такое explicit и зачем он нужен?

Ключевое слово explicit в C++ применяется к конструкторам (и, начиная с C++11, к операторам преобразования). Его главная цель — запретить неявные преобразования типов через этот конструктор. Когда вы пишете explicit, вы говорите компилятору: "Этот конструктор можно вызывать только явно, с помощью синтаксиса вроде ClassName(args) или static_cast<ClassName>(args)".

Давайте разберем ваш пример. У вас есть конструктор Vector(int size). Без explicit он является конструктором преобразования (converting constructor). Это означает, что компилятор может использовать его для неявного преобразования int в Vector:

Vector v = 10;  // Неявное преобразование: int -> Vector
processVector(42); // Ещё одно неявное преобразование

Компилятор создаёт временный объект Vector из числа 10, а затем копирует его в v (на самом деле, из-за оптимизации копирование может быть пропущено, но семантически это так).

Почему это опасно?

Неявные преобразования могут привести к неожиданному поведению. Представьте, что у вас есть функция, которая принимает Vector, а вы случайно передаёте число. Код скомпилируется, но вместо сообщения об ошибке вы получите объект, созданный из этого числа. Вот реальный пример из практики:

class Array {
public:
    Array(int size) : size_(size) { /* выделение памяти */ }
    // ... другие методы
private:
    int size_;
};

void printArray(const Array& arr) { /* ... */ }

int main() {
    printArray(100);  // Ошибка? Нет! Создаст Array(100) и передаст его
    return 0;
}

Если вы ожидали, что printArray будет принимать только настоящие массивы, такое неявное преобразование — это баг, который ждёт своего часа.

Как исправить с помощью explicit?

Достаточно добавить ключевое слово explicit перед конструктором:

class Vector {
public:
    explicit Vector(int size) {
        data = new int[size];
        sz = size;
    }
private:
    int* data;
    int sz;
};

// Теперь этот код не скомпилируется:
// Vector v = 10;       // Ошибка!
// processVector(42);   // Ошибка!

// Но явное создание всё ещё работает:
Vector v(10);          // OK
Vector v2 = Vector(10); // OK
processVector(Vector(42)); // OK
processVector(static_cast<Vector>(42)); // OK

Когда использовать explicit?

• Всегда для конструкторов с одним параметром, если только вы намеренно не хотите разрешить неявное преобразование. Это хорошая практика — по умолчанию делать конструкторы explicit.
• Для конструкторов, где параметр не является "очевидным" значением. Например, конструктор MyString(int size) — размер строки не является строкой, поэтому explicit обязателен.
• Для операторов преобразования (начиная с C++11): explicit operator bool() const; — чтобы избежать неявного преобразования объекта в bool в неожиданных контекстах.

Когда НЕ использовать explicit?

• Когда конструктор принимает несколько параметров (до C++11). В C++11 и новее конструкторы с несколькими параметрами тоже могут участвовать в неявных преобразованиях через списки инициализации, так что правило "лучше explicit" остаётся.
• Когда неявное преобразование семантически верно. Например, класс std::string имеет неявный конструктор от const char* — это удобно: std::string s = "hello"; интуитивно понятно.

Итог

Ключевое слово explicit — это инструмент для предотвращения случайных неявных преобразований. Используйте его по умолчанию для конструкторов с одним параметром. Если вы встретите код, где конструктор без explicit — спросите себя: "Действительно ли я хочу, чтобы int мог превратиться в мой класс без моего ведома?" В большинстве случаев ответ будет "нет".

std::shared_ptr<int> p = new int(5); // Неявное преобразование

std::shared_ptr<int> p(new int(5)); // Работает, но чуть длиннее

std::string s = "Hello, world!"; // Естественно и коротко

class MyBool {
public:
    explicit operator bool() const { return flag_; }
private:
    bool flag_;
};

MyBool b(true);
if (b) { /* OK, явное использование в условии */ }
bool x = b; // Ошибка! Неявное преобразование запрещено