🏛 Борьба с Variable Shadowing

Затенение (shadowing) — когда локальная переменная скрывает переменную из внешней области видимости с тем же именем

В классах затенение особенно коварно: локальная переменная или параметр может скрыть член класса. И компилятор промолчит.

class Config {
    int timeout_ = 5000;
    
public:
    void setTimeout(int timeout_) {  // параметр затеняет член!
        timeout_ = timeout_;  
        // Член класса НЕ изменился
    }
};

🍉 Способы решения проблемы

class Config {
    int timeout_ = 5000;
    
public:
    // 1. Разные имена
    void setTimeout(int newTimeout) {
        timeout_ = newTimeout;
    }
    
    // 2. Явный this->
    void setTimeoutAlt(int timeout_) {
        this->timeout_ = timeout_;
    }

    // 3. Через имя класса
    void setTimeoutBase(int timeout_) {
        Config::timeout_ = {timeout_};
    }
    
    // 4. Через временный объект
    void setTimeoutDumb(int timeout_) {
        *this = { .timeout = timeout_ };
        // Но лучше так не писать
    }
};

❗️ Включите -Wshadow-field для отлова таких багов.


📍Навигация: Вакансии • Задачи • Собесы

Библиотека C/C++ разработчика

#константная_правильность

✏️ Как одно ключевое слово ускоряет код?

final — это не только запрет наследования. Это подсказка компилятору для девиртуализации. Компилятор получает гарантию, что другой реализации не будет.


🍉 До и после:

class Base {
    virtual void process() = 0;
};

class Derived : public Base {
    void process() override final { /* ... */ }
    //                       ^^^^^ 
};

Теперь компилятор знает: Derived::process — последняя версия. При вызове через Derived* или Derived& он может девиртуализировать:

void hotPath(Derived& obj) {
    obj.process(); // прямой вызов, не через vtable
}

📍Навигация: Вакансии • Задачи • Собесы

Библиотека C/C++ разработчика

#под_капотом

👻 std::atexit — зачем регистрировать функции на выход?

Когда твоя программа завершается, нужно освободить ресурсы, закрыть логи, сохранить состояние. std::atexit позволяет зарегистрировать функции, которые вызовутся автоматически при нормальном завершении программы.

#include <cstdlib>
#include <iostream>

void cleanup() {
    std::cout << "Cleaning up resources...\n";
}

int main() {
    std::atexit(cleanup);
    std::cout << "Program running...\n";
    return 0; // cleanup() вызовется автоматически
}

Ключевой момент: функции вызываются в порядке, обратном регистрации (LIFO).

❗️ Важно: std::atexit работает только при нормальном завершении (return из main или std::exit). При std::abort или неперехваченных исключениях функции не вызовутся.

❗️Best practice: используй RAII и деструкторы вместо atexit, когда это возможно. atexit — для глобального состояния и C-совместимости.


✏️ Используешь ли ты atexit в своих проектах?

📍Навигация: Вакансии • Задачи • Собесы

Библиотека C/C++ разработчика

#под_капотом

🎯 Нестандартные форматы резюме

Классическое резюме живет 7 секунд в голове рекрутера — а дальше стирается. Как выделиться в 2026-м, когда на одну вакансию приходят сотни похожих PDF-ок?

➡️ В статье — 6 небанальных форматов: от сайта-резюме с геймификацией до ченджлога в духе заметок о релизе.

📍 Навигация: Вакансии • Задачи • Собесы

🐸 Библиотека Go-разработчика

🍴 Задача на выходные: до скольки считает стандарт?

Стандарт C++ гарантирует, что можно зарегистрировать минимум N функций через std::atexit. Найди баг в этом коде:

#include <cstdlib>
#include <iostream>

void dummy_handler() {
    static int counter = 0;
    std::cout << "Handler " << ++counter << "\n";
}

int main() {
    // Регистрируем 100 обработчиков
    for (int i = 0; i < 100; ++i) {
        if (std::atexit(dummy_handler) != 0) {
            std::cerr << "Failed at " << i << "\n";
            return 1;
        }
    }
    
    std::cout << "All registered!\n";
    return 0;
}

❓ Вопрос: Гарантирует ли стандарт, что все 100 обработчиков зарегистрируются? Какое минимальное количество гарантируется? Как правильно обработать ошибку регистрации?

📍Навигация: Вакансии • Задачи • Собесы

Библиотека C/C++ разработчика

#междусобойчик