Как устроен умный указатель?

Ключевое слово explicit в C++

Explicit — ключевое слово, которое запрещает неявные преобразования типов. Это одна из тех "маленьких" особенностей C++, которая может спасти от серьёзных багов.

Проблема: неявные преобразования

class String {
public:
    // БЕЗ explicit - неправильно!
    String(const char* str) {
        std::cout << "Converting C-string to String";
    }
};

int main() {
    String s1 = "Hello"; // OK - явное преобразование
    String s2("World"); // OK - явное преобразование
    
    // ПРОБЛЕМА: неявное преобразование!
    const char* cstr = "test";
    String s3 = cstr; // Компилятор неявно вызовет конструктор!
    
    // Ещё хуже:
    void process(String s) {}
    
    process("implicit conversion"); // Создаст временный String!
}

Почему это плохо:

• Неожиданные преобразования
• Скрытые вызовы конструкторов
• Производительность (создание временных объектов)
• Трудно отследить в коде

Решение: explicit

class String {
public:
    // С explicit - правильно!
    explicit String(const char* str) {
        std::cout << "Converting C-string to String";
    }
};

int main() {
    String s1 = "Hello"; // ОШИБКА - неявное преобразование запрещено!
    String s2("World"); // OK - явное преобразование
    String s3 = String("test"); // OK - явное
    
    void process(String s) {}
    process("test"); // ОШИБКА - неявное преобразование!
    process(String("test")); // OK
}

Explicit для конструкторов

class Vector {
private:
    std::vector<int> data;
    
public:
    // БЕЗ explicit - опасно!
    Vector(int size) {
        data.resize(size);
    }
};

// ПРОБЛЕМА
void print_vector(Vector v) {
    // Работаем с вектором
}

int main() {
    print_vector(10); // ОШИБКА! Компилятор неявно создаст Vector(10)
    // Программист хотел передать 10, получил вектор размером 10!
}

// РЕШЕНИЕ
class Vector {
public:
    explicit Vector(int size) {
        data.resize(size);
    }
};

int main() {
    print_vector(10); // Теперь ОШИБКА КОМПИЛЯТОРА!
    print_vector(Vector(10)); // OK - явно
}

Explicit для оператора преобразования (C++11+)

class SmartPointer {
private:
    int* ptr;
    
public:
    SmartPointer(int* p) : ptr(p) {}
    
    // БЕЗ explicit - неправильно!
    operator bool() {
        return ptr != nullptr;
    }
};

int main() {
    SmartPointer ptr(new int(42));
    
    // ПРОБЛЕМА: неявное преобразование в bool
    int x = ptr; // Компилятор преобразует в bool, потом в int!
    if (ptr) { } // OK - ожидаемо
}

// ПРАВИЛЬНО
class SmartPointer {
public:
    explicit operator bool() {
        return ptr != nullptr;
    }
};

int main() {
    SmartPointer ptr(new int(42));
    
    int x = ptr; // ОШИБКА - неявное преобразование запрещено
    if (ptr) { } // OK - явное контекстное преобразование
    bool b = (bool)ptr; // OK - явное приведение
}

Практический пример: класс денег

class Money {
private:
    double amount;
    
public:
    explicit Money(double amt) : amount(amt) {}
    
    double get_amount() const { return amount; }
};

// БЕЗ explicit - опасно!
void charge_account(Money amount) {
    std::cout << "Charging: " << amount.get_amount();
}

// Функция параметров платежа
void setup_payment(Money min, Money max, int iterations) {}

int main() {
    // С обычным конструктором (БЕЗ explicit):
    charge_account(100.0); // Неявно создаст Money(100)! Ужас!
    
    setup_payment(0, 1000, 10); // Что если случайно переставить параметры?
    // setup_payment(1000, 0, 10) - не ловится ошибка!
    
    // С explicit:
    charge_account(100.0); // ОШИБКА КОМПИЛЯТОРА!
    charge_account(Money(100.0)); // OK - явно
    setup_payment(Money(0), Money(1000), 10); // Явно - безопаснее
}

Explicit для шаблонов (C++20)

template<typename T>
class Container {
public:
    // Конструктор шаблона может быть explicit
    explicit Container(T value) {}
};

int main() {
    Container<int> c1 = 42; // ОШИБКА - неявное преобразование
    Container<int> c2(42);  // OK
}

Правило большого пальца

Всегда использовать explicit для конструкторов, принимающих один аргумент, если это имеет смысл:

class Date {
public:
    explicit Date(int timestamp); // Смысл? Да - уникальное преобразование
};

class Temperature {
public:
    // Здесь explicit НЕ нужен - естественное преобразование
    Temperature(double celsius) : value(celsius) {}
private:
    double value;
};

Сравнение с другими языками

Java:

// В Java нет явного аналога explicit, преобразования контролируются типом
String s = new String("Hello"); // Всегда явно

Python:

# В Python нет explicit, преобразования неявны по умолчанию
s = str(42) # Явное преобразование

C#:

// В C# есть похожее управление через модификаторы
class Currency {
    public static explicit operator int(Currency c) { }
}

Лучшие практики

Правило 1: По умолчанию explicit

// ХОРОШО - явный конструктор
class UserId {
    explicit UserId(int id) {}
};

// ПЛОХО - неявное преобразование
class UserId {
    UserId(int id) {} // Опасно!
};

Правило 2: Только когда естественно

// Естественное преобразование - можно без explicit
class Fraction {
    Fraction(int numerator); // 5 -> Fraction(5, 1)
};

// Неестественное - нужен explicit
class FileHandle {
    explicit FileHandle(int fd); // int -> FileHandle? Странно
};

Правило 3: Документируй решение

class Distance {
public:
    // Явное преобразование для безопасности
    explicit Distance(double meters) : m_meters(meters) {}
private:
    double m_meters;
};

Заключение

Explicit - это простой способ:

• ✓ Предотвратить неожиданные преобразования
• ✓ Делать код яснее (явность лучше неявности)
• ✓ Поймать ошибки на уровне компилятора
• ✓ Улучшить производительность (нет скрытых временных объектов)

Используй explicit по умолчанию, удаляй только когда у тебя есть веская причина!