Что означает ключевое слово explicit в C++ и зачем оно нужно?

Что такое неявное преобразование и почему это проблема

Ключевое слово explicit в C++ используется для запрета неявных преобразований типов через конструкторы (и, начиная с C++11, операторы преобразования). Ваш пример — классическая иллюстрация проблемы: конструктор String(int) без explicit позволяет компилятору автоматически преобразовывать int в String при вызове функции. Это может привести к неожиданному поведению и трудноуловимым багам.

Когда вы пишете printString(42), компилятор видит, что функция ожидает const String&, а передаётся int. Поскольку существует конструктор String(int), компилятор создаёт временный объект String из числа 42. Это называется неявным преобразованием (implicit conversion).

Как explicit решает проблему

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

class String {
public:
    explicit String(int size) {
        // инициализация строки с заданным размером
    }
};

void printString(const String& s) { /* ... */ }

int main() {
    // printString(42); // Ошибка компиляции! Неявное преобразование запрещено
    printString(String(42)); // Так можно — явное создание объекта
    printString(static_cast<String>(42)); // Или так
    return 0;
}

Теперь строка printString(42) вызовет ошибку компиляции, потому что explicit запрещает неявное преобразование. Программист должен явно указать, что хочет создать объект String из числа.

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

• Конструкторы с одним параметром (кроме конструкторов копирования/перемещения) — почти всегда стоит делать explicit, если только вы не хотите разрешить неявное преобразование осознанно.
• Конструкторы с несколькими параметрами (до C++11) — если у них есть значения по умолчанию, они могут работать как однопараметрические. Например: String(int size = 0, char fill = ' ').
• Операторы преобразования (начиная с C++11) — например, explicit operator bool() const; предотвращает неожиданное преобразование объекта в bool в логических контекстах.

Когда неявное преобразование полезно

Иногда неявные преобразования — это фича, а не баг. Классические примеры:

• Умные указатели — конструктор std::shared_ptr от сырого указателя неявно не преобразует, это было бы опасно. Но конструктор std::string от const char* — неявный, чтобы можно было писать std::string s = "hello";.
• Обёртки числовых типов — класс SafeInt может иметь неявный конструктор от int, чтобы безопасно работать с числами.
• Адаптеры и фасады — если класс представляет собой «лёгкую обёртку» вокруг другого типа, неявное преобразование может упростить код.

Но в большинстве случаев, особенно для новичков, правило простое: если сомневаетесь — делайте explicit. Это защитит вас от случайных ошибок и сделает код более читаемым.

Дополнительный совет: C++11 и списки инициализации

Начиная с C++11, explicit также работает с конструкторами, принимающими std::initializer_list. Например:

class Vector {
public:
    explicit Vector(std::initializer_list<int> list) { /* ... */ }
};

Vector v = {1, 2, 3}; // Ошибка: explicit запрещает неявное преобразование
Vector v2({1, 2, 3}); // ОК: явная инициализация

Это предотвращает случайное создание объекта из списка значений, когда вы хотели вызвать другой конструктор.

class Duration {
public:
    explicit Duration(int seconds) : sec(seconds) {}
private:
    int sec;
};

void wait(Duration d) { /* ... */ }

int main() {
    wait(60); // Ошибка — хорошо! 60 секунд или 60 миллисекунд?
    wait(Duration(60)); // Явно указываем: 60 секунд
}

template<typename T>
void foo(T t) { /* ... */ }

// Без explicit: foo(42) мог бы создать String, если T = String
// С explicit: foo(42) всегда будет вызываться с int