uk
Feedback

Не попадись на ботовода! Telemetrio знаходить і позначає такі канали мітками 👉 Хочеш бачити мітку, оформляй підписку

Грокаем C++

Грокаем C++

Відкрити в Telegram

Два сеньора C++ - Владимир и Денис - отныне ваши гиды в этом дремучем мире плюсов. По всем вопросам (+ реклама) @ninjatelegramm Менеджер: @Spiral_Yuri Реклама: https://telega.in/c/grokaemcpp Мы на TGstat: https://tgstat.ru/channel/@grokaemcpp/stat

Показати більше
9 357
Підписники
-124 години
+147 днів
+1430 днів
Архів дописів
​​WAT #опытным Спасибо, @Ivaneo, за любезно предоставленный примерчик в рамках рубрики #ЧЗХ. "Век живи - век учись" - сказал Луций Сенека. "Век живи - век учи С++" - реалии нашей жизни. Просто посмотрите на следующий код:
struct Foo
{
  void Bar();
};

void Foo::Foo::Foo::Foo::Foo::Foo::Foo::Foo::Foo::Foo::Foo::Foo::Bar()
{
    printf("Foofoo!");
}

int main()
{
    Foo f;
    f.Bar();
    return 0;
}
И он компилируется. WAT? Это называется injected class name. Имя класса доступно из скоупа этого же класса. Так сделано для того, чтобы поиск имени X внутри класса X всегда разрешался именно в этот класс. Такое поведение может быть полезно в таком сценарии:
void X() { }
class X {
public:
  static X Сreate() { return X(); }
};
injected class name гарантирует, что из метода Сreate будет возвращен именно инстанс класса Х, а не результат вызова функции Х. Это также полезно внутри шаблонов классов, где имя класса можно использовать без списка аргументов шаблона, например, используя просто Foo вместо полного идентификатора шаблона Foo<blah, blah, blah>. Ну и побочным эффектом такого поведения является возможность написания длиннющей цепочки из имен класса. Так что это не у вас в глазах двоится, это плюсы такие шебутные) Find yourself within. Stay cool. #cppcore
11 жовт 2025, 08:00

Готовы с нуля создавать телекоммуникационные решения для беспроводных мобильных сетей и сопутствующих услуг? Тогда участвуйте
Готовы с нуля создавать телекоммуникационные решения для беспроводных мобильных сетей и сопутствующих услуг? Тогда участвуйте в SPRINT OFFER C++ Software Engineer и получите оффер всего за 3 дня 💻 У нас: 🚀 Удалённый формат работы или в офисах городов присутствия (Москва, СПб, Нижний Новгород, Екатеринбург, Минск). 🚀 Реальный карьерный рост: как вертикальный, так и горизонтальный. 🚀 Амбициозные проекты и уникальная команда инженеров. 🚀 Учебный портал с лекциями от экспертов, участие в конференциях, изучение английского и дополнительное обучение на внешних курсах. 🚀 ДМС с первого дня, консультации юристов, психологов и экспертов по ЗОЖ. Мы в поиске: Разработчиков C++ (Middle/Senior/Tech Lead) с опытом в промышленной разработке от 3 лет, уверенным знанием C/C++ и Linux, а также сетей, базирующихся на TCP/IP. Направления, которым вы нужны: Telecom Platform и разработка базовых станций с поддержкой LTE/GSM. В команде Telecom Platform инженеры разрабатывают полное платформенное решение для телекоммуникационных систем, а разработчики базовой станции LTE/GSM создают высоконагруженные системы, которые обеспечивают связь как критически важных, так и новых поколений. 💙 Прочитать подробнее можно по ссылке. Отправляйте заявку до 19 октября и присоединяйтесь к YADRO!
11 жовт 2025, 05:00
31 жовт 2025, ~03:37

​​Гарантия отсутствия исключений #новичкам Переходим к самой сильной гарантии - отсутствие исключений. В сам язык С++(new, dynamic_cast), и в его стандартную библиотеку в базе встроены исключения. Поэтому писать код без исключений в использованием стандартных инструментов практически невозможно. Вы конечно можете использовать nothrow new и написать свой вариант стандартной библиотеки и других сторонних решений. И кто-то наверняка так делал. Но в этом случае разработка как минимум затянется, а как максимум вы бросите это гиблое дело. Поэтому повсеместно предоставлять nothow гарантии с использованием стандартных инструментов не всегда реалистично. Но если такой термин есть, значит такие гарантии можно предоставлять для отдельных сущностей. Давайте как раз об этих сущностях и поговорим. Но для начала проясним термины. Под гарантией отсутствия исключений подразумевается обычно 2 понятия: nothrow и nofail. nothrow подразумевает отсутствие исключений, но не отсутствие ошибок. Говорится, что ошибки репортятся другими средствами(в основном через глобальное состояние, потому что деструктор ничего не возвращает) или полностью скрываются и игнорируются. Примером сущностей с nothrow гарантией является деструкторы. С С++11 они по-умолчанию помечены noexcept. В основном это сделано для того, чтобы при раскрутке стека не получить double exception. Но деструкторы могу фейлиться. Просто никаких средств, кроме глобальных переменных для репорта ошибок невозможно использовать. Они ведь ничего не возвращают, а исполняются скрытно от нас(если вы используете RAII конечно). nofail же подразумевает полное отсутствие ошибок. nofail гарантия ожидается от std::swap, мув-конструкторов классов и других функций с помощью которых достигается строгая гарантия исключений. Например в swap-идиоме std::swap и мув-конструкторы используются для определения небросающего оператора присваивания. nofail гарантиями также должны обладать функторы-коллбэки модифицирующих алгоритмов. std::sort не предоставляет никаких гарантий на состояние системы, если компаратор бросит эксепшн. В языке в целом эти гарантии обеспечиваются ключевым словом noexcept. При появлении этой нотации компилятор понимает, что для этой функций не нужно генерировать дополнительный код, необходимый для обработки исключений. Но у этого есть своя цена: если из noexcept функции вылетит исключение, то сразу же без разговоров вызовется std::terminate. Provide guarantees. Stay cool. #cppcore #cpp11
10 жовт 2025, 12:00

​​Строгая гарантия исключений #новичкам Базовая гарантия - это конечно хорошо, наше приложение будет корректно работать, даже если что-то пойдет не так. Но иногда этого недостаточно. Иногда нам нужно, чтобы ошибка операции вообще никак не повлияла на текущее состояние системы. Либо операция выполнилась и все хорошо, либо она бросила исключение, но после его отлова система находится в том же состоянии, что и до выполнения операции. Такое свойство операций называется транзакционность. Транзакция может либо выполниться полностью, либо все результаты промежуточных операций в ней откатываются до состояния до начала исполнения транзакции. Это важно, когда ваша операция требует выполнения нескольких промежуточных операций, постепенно меняющих систему. Если остановиться посередине, то уже невозможно или очень сложно будет восстановить консистентность данных. Давайте перепишем оператор присваивания класс IntArray из предыдущего поста так, чтобы он предоставлял строгую гарантию:
class IntArray {
    int *array;
    std::size_t nElems;

public:
    // ...

    ~IntArray() { delete[] array; }

    IntArray(const IntArray &that);  // nontrivial copy constructor

    IntArray &operator=(const IntArray &rhs) {
        int *tmp = nullptr;
        if (rhs.nElems) {
            tmp = new int[rhs.nElems];
            std::memcpy(tmp, rhs.array, rhs.nElems * sizeof(*array));
        }
        delete[] array;
        array = tmp;
        nElems = rhs.nElems;
        return *this;
    }

    // ...
};
В этот раз мы ничего не изменяем в самом объекте до тех пор, пока не выделим новый буфер и не скопируем туда элементы rhs. И только после этого выполняем обновление самого объекта с помощью небросающих инструкций. Хрестоматийный пример из стандартной библиотеки - вектор с его методом push_back. Если у типа есть небросающий перемещающий конструктор, то метод предоставляет строгую гарантию. Вот примерно как это работает:
template <typename T>
class vector {
private:
    T *data = nullptr;
    size_t size = 0;
    size_t capacity = 0;

    void reallocate(size_t new_capacity) {
        // allocate memory
        T *new_data =
            static_cast<T *>(::operator new(new_capacity * sizeof(T)));
        size_t new_size = 0;

        try {
            // Move or copy elements 
            for (size_t i = 0; i < size; ++i) {
                new (new_data + new_size) T(std::move_if_noexcept(data[i]));
                ++new_size;
            }
        } catch (...) {
            // Rollback in case of exception
            for (size_t i = 0; i < new_size; ++i) {
                new_data[i].~T();
            }
            ::operator delete(new_data);
            throw;
        }

        // cleanup
        // ...
    }

public:
    void push_back(const T &value) {
        if (size >= capacity) {
            size_t new_capacity = capacity == 0 ? 1 : capacity * 2;

            // save for rollback
            T *old_data = data;
            size_t old_size = size;
            size_t old_capacity = capacity;

            try {
                reallocate(new_capacity);
            } catch (...) {
                // restore
                data = old_data;
                size = old_size;
                capacity = old_capacity;
                throw;
            }
        }

        // actually insert element
        // ...
    }

};
в хэлпере reallocate используется std::move_if_noexcept, который условно кастит в rvalue ссылке, если мув конструктор noexcept. И только в этом случае можно предоставить строгую гарантию: если вы уже повредили один из исходных объектов, его уже никак не восстановить. А безопасное перемещение элементов гарантирует готовый к использованию новый расширенный буфер. Be strong. Stay cool. #cppcore
09 жовт 2025, 06:00

Платите без ограничений Иннокентий проснулся, позавтракал, вышел из дома, надел наушники и включил любимую подборку на Spotify по дороге в офис. Пришел в офис, попил кофеек и сел за задачи. Copilot настроен для автокомплита кода + есть доступ к Claude. Кенни сегодня молодец, решил много проблем и быстро закрыл задачу. После тяжелого трудового дня пришел домой и поиграл в новую игрушку из Steam'а. Или позалипал в новый сериальчик от Netflix. А потом реально проснулся и понял, что это все был сон😨. И взгрустнул, потому что у него нет иностранной карты, чтобы оплачивать все эти сервисы. Но это теперь не проблема, потому что появился сервис МТС Оплата! Там можно в пару кликов оплатить подписку более 150 зарубежных сервисов через СБП и с минимальной комиссией. Всего 5 минут и подписка уже у вас. И никто не попросит ваш паспорт и снилс. Только почта. Кенни теперь не грустит и вы тоже не грустите с МТС Оплатой🤗
09 жовт 2025, 05:00
10 жовт 2025, ~05:24

​​Базовая гарантия исключений #новичкам Вспомним свойства базовой гарантии: после возникновения исключения в программе не должно быть утечек ресурсов и должны сохраняться все инварианты классов. И не всегда базовой гарантии легко удовлетворить. Поскольку исключения добавляют в программу дополнительные пути выполнения кода, крайне важно учитывать последствия работы кода по таким путям и избегать любых нежелательных эффектов, которые в противном случае могут возникнуть. Давайте посмотрим на примере:
class IntArray {
    int *array;
    std::size_t nElems;

public:
    // ...

    ~IntArray() { delete[] array; }

    IntArray(const IntArray &that);  // nontrivial copy constructor
    IntArray &operator=(const IntArray &rhs) {
        if (this != &rhs) {
            delete[] array;
            array = nullptr;
            nElems = rhs.nElems;
            if (nElems) {
                array = new int[nElems];
                std::memcpy(array, rhs.array, nElems * sizeof(*array));
            }
        }
        return *this;
    }

    // ...
};
Внутренний инвариант класса IntArray - член array является валидным (возможно, нулевым) указателем, а член nElems хранит количество элементов в массиве. В операторе присваивания освобождается память текущего array'я и присваивается значение счётчику элементов nElems до выделения нового блока памяти для копии. В результате, если из new вылетит исключение, то array будет нулевым, а размер массива нет. Это нарушение инварианта и таким объектом просто небезопасно пользоваться. Метод size потенциально вернет ненулевой размер, а закономерное использование следом оператора[] приведет к неопределенному поведению. Код, который избегает подобных нежелательных эффектов, называется exception safe. То есть предоставление базовой гарантии уже говорит о том, что ваш код "exception safe". Допустим, что ваш класс предоставляет базовую гарантию исключений. Какие выводы мы можем из этого сделать? Ну сохранены инварианты, а значения-то какие будут у полей? В том-то и дело, что конкретные значения неизвестны. И это сильно ограничивает практическое использование таких объектов. По сути единственное, что с ним можно гарантировано безопасно сделать - это разрушить. И это главное. Вся магия с раскруткой стека и вызовом деструктором локальных объектов работает только если деструкторы вызываются безопасно. А для этого объект должен быть в валидном, но необязательно определенном, состоянии. То есть вы в принципе не можете восстановить работоспособность приложения, если ваши инструменты не предоставляют хотя бы базовую гарантию. Здесь кстати можно провести параллель с мувнутыми объектами: ими тоже особо не попользуешься и по хорошему их надо просто удалить. Примером предоставления только базовой гарантии может быть использование какой-нибудь базы данных. Если при выполнении запроса фреймворк выкинул исключение, например потому что соединение отвалилось, то объект для работы с базой остался в валидном состоянии, но нет никакой информации о том, выполнился запрос или нет:
auto db = std::make_shared<DBConnection>(credentials);
try {
  auto result = db->Execute("UPDATE ...");
  process(result);
} catch (std::exception& ex) {
  std::cout << "We can cannot rely on table state and must retry with that in mind" << std::endl;
  // retry
}
Поэтому мы должны иметь ввиду это неопределенное состояние коннекшена и базы при выполнении ретраев. Provide guarantees. Stay cool. #cppcore
08 жовт 2025, 06:00

​​Гарантии безопасности исключений #новичкам Программа на С++ - очень интересное явление. Вроде мощный, подкаченный, умный и скоростной парень. Но вот проблема. Ходить не умеет нормально. То в ноги себе стреляет, то падает периодически. В общем, беда у него с ходьбой. У этого могут быть разные причины. Все из них даже трудно в голове удержать. Но сегодня обсудим, какие есть гипсы, лангеты и костыли, которые помогут этому парню нормально ходить при работе с исключениями. Даже не зная, что вы работаете с исключениями - вы уже работаете с ними. Даже обычный, казалось бы, безобидный new может кинуть std::bad_alloc. И это core языка. Стандартная библиотека пронизана исключениями. Обрабатывать исключения можно по-разному и это будет давать разные результаты. От того, как обрабатываются исключения в модуле, зависит, какие гарантии он может дать в случае возникновения исключительной ситуации. А это очень важная штука, потому что взаимодействующий с модулем код полагается на его адекватное поведение, которое с легкостью может быть нарушено, если нет гарантий безопасности. Итак, существует 3 гарантии безопасности исключений: Базовая гарантия. Формулировка разнится, но более общая звучит так: "после возникновения исключения и его обработки программа должна остаться в согласованном состоянии". Теперь на рабоче-крестьянском: не должно быть утечек ресурсов и должны сохраняться все инварианты классов. С утечками, думаю, все понятно. Инвариант - некое логически согласованное состояние системы. Если класс владеет массивом и содержит поле для его размера, то инвариантом этого класса будет совпадение реального размера массива со значением поля-размера. Для класса "легковая машина" инвариантом будет количество колес - 4. Обычная машина без одного или нескольких колес просто не едет. И для того, чтобы машина корректно работала, количество колес должно быть одинаково - 4. Или например, нельзя, чтобы дата создания чего-то была больше текущего дня, ну никак. Вот такие штуки должны сохраняться. Строгая гарантия. Если при выполнении операции возникает исключение, операция не должна оказать на систему никакого влияния. То есть пан или пропал. Либо вся операция выполняется успешно и ее результат применяется, либо система откатывается в состояние до выполнения операции. Это свойство программы называется транзакционностью. Гарантия отсутствия исключений. Ни при каких обстоятельствах не будет брошено исключение. Легко сказать, но тяжело сделать. С++ и его стандартная библиотека разрабатывались с учетом использования исключений. И это накладывает свои ограничения на отсутствие исключений. Мы все-таки не на Go пишем. Ну и есть еще одна гарантия - отсутствие каких-либо гарантий. Мама - анархия, во всей красе. Тема важная, будем потихоньку ее разбирать с примерами по каждой гарантии. Be a guarantor. Stay cool. #cppcore
07 жовт 2025, 06:00

⌨️ Открытый урок «Инструменты много поточного программирования в стандартной библиотеке на С++» 🗓 14 октября в 20:00 МСК 🆓
⌨️ Открытый урок «Инструменты много поточного программирования в стандартной библиотеке на С++» 🗓 14 октября в 20:00 МСК 🆓 Бесплатно. Урок в рамках старта курса «C++ Developer. Professional». 🎯 Что рассмотрим на вебинаре: ✔️Инструменты много поточного программирования в стандартной библиотеке ✔️Классы стандартной библиотеки, ответственные за создание многопоточности ✔️Примитивы синхронизации 👥 Кому будет интересно: - junior, junior+ C++ Разработчикам 🔗 Ссылка на регистрацию: https://otus.pw/Z9tf/ Реклама. ООО «Отус онлайн-образование», ОГРН 1177746618576
07 жовт 2025, 03:00
12 жовт 2025, ~13:16

​​Ответ #новичкам Многие из вас подумали, что будет ошибка компиляции. В целом, логичная цепочка мыслей: ну как же можно мувнуть данные из константной ссылки? Она же неизменяема. Но она все же неверная. Правильный ответ: на консоль выведется "copy ctor". Копия? Мы же муваем! Сейчас разберемся. Но для начало вспомним сам пример:
#include <iostream>

struct Test {
    Test() = default;
    Test(const Test &other) {
        std::cout << "copy ctor" << std::endl;
    }
    Test(Test &&other) {
        std::cout << "move ctor" << std::endl;
    }
    Test &operator=(const Test &other) = default;
    Test &operator=(Test &&other) = default;
    ~Test() = default;
};

int main() {
    Test test;
    const Test &ref = test;
    (void)std::move(ref);
    auto emigma = std::move(ref);
}
На самом деле проблема в нейминге. Все вопросы к комитету. Это они имена всему плюсовому раздают. std::move ничего не мувает. Она делает всего лишь static_cast. Но не просто каст к правой ссылке, это не совсем корректно. Посмотрим на реализацию std::move:
template <class T>  
constexpr typename std::remove_reference<T>::type&& move(T&& t) noexcept {  
  return static_cast<typename std::remove_reference<T>::type&&>(t);  
}
Обратите внимание, что от типа отрезается любая ссылочность и только затем добавляется правоссылочность. Но константность-то никуда не уходит. По сути результирующий тип выражения std::move({константная левая ссылка}) это константная правая ссылка. Чтобы это проверить, перейдем на cppinsights:
Test test;
const Test &ref = test;
using ExprType = decltype(std::move(ref));

// под капотом ExprType вот чему равен

using ExprType = const Test &&;
Так как мы просто кастуем к валидному типу, мув успешно отрабатывает, но строчка (void)std::move(ref); не дает в консоли никакого вывода, потому что никаких новых объектов мы не создаем. Теперь про копирование. Вспомним правила приведения типов. const T&& может приводится только к const T&. То есть единственный конструктор, который может вызваться - это копирующий конструктор. Интересная ситуация, конечно, что "перемещение" может приводить к копированию в плюсах. Но имеем, что имеем. Терпим и продолжаем грызть гранит С++. Give a proper name. Stay cool. #cppcore #template
05 жовт 2025, 06:00

Какой результат попытки компиляции и запуска кода?
Anonymous voting
04 жовт 2025, 05:00

Квиз #новичкам Сегодня короткий, но от того не менее интересный #quiz, . Можно было бы разобрать вопрос: "а что случится, если я мувну константную ссылку?", но так не очень интересно. Поэтому давайте проверим ваше знание мув-семантики. У меня к вам всего один вопрос: Какой результат попытки компиляции и запуска следующего кода:
#include <iostream>

struct Test {
    Test() = default;
    Test(const Test &other) {
        std::cout << "copy ctor " << std::endl;
    }
    Test(Test &&other) {
        std::cout << "move ctor " << std::endl;
    }
    Test &operator=(const Test &other) = default;
    Test &operator=(Test &&other) = default;
    ~Test() = default;
};

int main() {
    Test test;
    const Test &ref = test;
    (void)std::move(ref);
    auto emigma = std::move(ref);
}
Challenge yourself. Stay cool.
04 жовт 2025, 05:00

​​Идиома IILE #опытным Неплохой практикой написания кода является определение переменных, которые не изменяются, как const. Это позволяет коду был более экспрессивным, явным, а также компилятор в этом случае может чуть лучше рассуждать о коде и оптимизировать. И это не требует ничего сложного:
const int myParam = inputParam * 10 + 5;
// or
const int myParam = bCondition ? inputParam * 2 : inputParam + 10;
Но что делать, если переменная по сути своей константа, но у нее громоздская инициализация на несколько строк?
int myVariable = 0; // this should be const...

if (bFirstCondition)
    myVariable = bSecondCindition ? computeFunc(inputParam) : 0;
else
    myVariable = inputParam * 2;

// more code of the current function...
// and we assume 'myVariable` is const now
По-хорошему это уносится в какую-нибудь отдельную функцию. Но тогда теряется контекст и нужно будет прыгать по коду. Хочется и const сделать, и в отдельную функцию не выносить. Кажется, что на двух стульях не усидишь, но благодаря лямбдам мы можем это сделать! Есть такая идиома IILE(Immediately Invoked Lambda Expression). Вы определяете лямбду и тут же ее вызываете. И контекст сохраняется, и единовременность инициализации присутствует:
const int myVariable = [&] {
    if (bFirstContidion)
        return bSecondCondition ? computeFunc(inputParam) : 0;
    else
       return inputParam * 2;
}(); // call!
Пара лишних символов, зато проблема решена. Тут есть одно "но". Вроде все хорошо, но немного напрягает, что все это можно спутать с простым определением лямбды, если не увидеть скобки вызова в конце. Тоже не беда! Используем std::invoke:
const int myVariable = std::invoke([&] {
    if (bFirstContidion)
        return bSecondCondition ? computeFunc(inputParam) : 0;
    else
       return inputParam * 2;
});
Теперь мы четко и ясно видим, что лямбда вызывается. В таком виде прям кайф. Эту же технику можно использовать например в списке инициализации конструктора, например, если нужно константное поле определить(его нельзя определять в теле конструктора). Be expressive. Stay cool. #cpp11 #goodpractice
03 жовт 2025, 05:00

Уже 23 октября узнаем больше о хакрдкорной разработке dev-to-dev решений Техплатформа Городских сервисов Яндекса проводит митап, на котором эксперты поделятся опытом создания архитектуры нагруженной системы, обрабатывающей сотни тысяч rps в брокере сообщений на MongoDB, и как писать IO-bound сервисы под высокими нагрузками на С++ так же как на Go. В программе выступления Антона Полухина, Ромы Елизарова, Лёши Иванова и Влада Назарова, а также нетворкинг в неформальной атмосфере. Если интересуетесь разработкой dev-to-dev решений и вы опытный разработчик, обязательно приходите. 👉 23 октября, сбор гостей с 18:00 👉 Москва, офлайн Регистрируйтесь и зовите коллег! Мероприятие бесплатное. Количество мест ограничено — пожалуйста, дождитесь нашего подтверждения. Реклама. ООО «Яндекс.Такси». ИНН 7704340310.
03 жовт 2025, 04:00
04 жовт 2025, ~04:00

​​Как анализировать процесс компиляции? #опытным Если вы уже дошли до ручки и у вас ежедневный передоз кофеином от безделья во время сборки проекта, пора что-то менять. Но с чего начать? Как понять, что конкретно занимает так много времени при компиляции? И действительно, семь раз отмерь, один раз отрежь. Сколько бы вы не теоретизировали о проблемных местах в сборке, это не системный подход. Вам нужны цифры, чтобы хоть на что-то объективное опереться. Сегодня поговорим об инструментах анализа сборки. Здесь будет только gcc и clang, с виндой у нас опыта особо нет. Знающие могут подсказать в комментах. Поехали. GCC Есть определенный набор опций компиляции, которые говорят компилятору выводить подробную информацию о внутренних процессах, происходящих при обработке цппшников и хэдэров. Для гцц это:
g++ -fstats  -fstack-usage  -ftime-report  -ftime-report-details -c large_file.cpp -o large_file.o

// или в CMakeLists.txt прописать

set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fstats -fstack-usage -ftime-report -ftime-report-details")
при компиляции вам выдастся что-то такое:
******
time in header files (total): 0.259532 (22%)
time in main file (total): 0.884263 (76%)
ratio = 0.293501 : 1

******
time in <path_to_header_1>: 0.000444 (0%)
time in <path_to_header_2>: 0.008682 (1%)
time in <path_to_header_3>: 0.885595 (76%)
/.../

Time variable                                  wall           GGC
 phase setup                        :   0.05 (  4%)  1813k (  3%)
 phase parsing                      :   1.11 ( 94%)    55M ( 97%)
 phase lang. deferred               :   0.01 (  1%)   128k (  0%)
// other metrics
 TOTAL                              :   1.18           57M
Вы получите подробную статистику о времени, потраченном на анализ конкретных хэдэров и на каждый отдельный этап обработки единицы трансляции. Если у вас много шаблонов - вам об этом скажут. Если сложное разрешение перегрузок - тоже. И тд. И такая портянка генерируется для каждого цппшника. Будьте осторожнее при сборке, используйте make в один поток, иначе не поймете, что куда относится. Clang Чтобы получить подобный репорт для шланга нужна опция:
clang++ -ftime-trace -c large_file.cpp -o large_file.o

set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -ftime-trace")
Плюс к этому у шланга с инструментами как всегда по-веселее, чем у гцц. Есть утилитка ClangBuildAnalyzer, который позволяет агрегировать и предоставлять в более читаемом виде информацию о общих таймингах компиляции и самых трудозатратных местах сборки. Можно собрать из исходников по ссылочке и использовать его так:
// обязательно собрать проект с опцией -ftime-trace

ClangBuildAnalyzer --all build/ build_analysis.json
ClangBuildAnalyzer --analyze build_analysis.json
Вывод будет примерно такой:
**** Files that took longest to codegen (compiler backend):
 // files list

**** Templates that took longest to instantiate:
// templates list

**** Functions that took longest to compile:
// functions list

etc...
Попробуйте начать с этих инструментов и детально проанализировать, где вы тратите больше всего времени. Если у вас глаза вытекают, глядя на статистику - скормите это добро нейронке. Если слишком много данных для анализа(большой проект), можно скрипт аггрегирующий написать. В любом случае, измерение - залог качественного результата. Look before you leap. Stay cool. #tools
02 жовт 2025, 08:00

〰️ Как оживить сигнал в микроконтроллере? В цифровом мире всё крутится вокруг нулей и единиц. Но когда нужно управлять мотором, формировать звук или регулировать яркость света, без цифро-аналогового преобразователя (ЦАП) не обойтись. 📆 9 октября в 20:00 МСК приглашаем на открытый урок, где мы: – разберём разные методы реализации ЦАП (PWM+RC, R2R, внешняя микросхема, цифровой потенциометр); – сравним их по частоте, разрядности, ресурсоёмкости и стоимости; – обсудим реальные примеры применения в embedded-проектах. ❗️Этот вебинар будет полезен инженерам-электронщикам, embedded-разработчикам и программистам микроконтроллеров. 👉 Открытый урок проходит в преддверие старта курса «Электроника и электротехника». Регистрация открыта: https://otus.pw/jGHwv/ Реклама. ООО «Отус онлайн-образование», ОГРН 1177746618576, www.otus.ru
02 жовт 2025, 05:00
05 жовт 2025, ~05:27

​​shared libraries #опытным И еще один способ уменьшить время сборки проекта. А точнее линковки. Идея такая: вы разбиваете свой проект на отдельные, независимые модули и компилируете их как разделяемые библиотеки. Дальше динамически линкуете эти библиотеки к своему исполняемому файлу. Почему в этом случае линковка быстрее? Для того, чтобы это понять, нужно знать, что происходит при статической линковке. На вход принимаются много объектных файлов и статических библиотек и компановщик выполняет примерно следующий набор действий: 1️⃣ Разрешение символов - для каждого неопределенного символа ищется определение. 2️⃣ Создание единого адресного пространства - линковщик определяет окончательные адреса для всех сегментов кода и данных и объединяет однотипные секции из разных объектных файлов. 3️⃣ Применение релокаций - в объектных файлах и статических либах адреса указаны относительно и линковщик пересчитывает все адреса в абсолютные значения. Так вот при динамической линковке компановщику лишь нужно проверить, что в библиотеке есть символы, которые используются в исполняемом файлы, поставить на месте использования символов заглушки, ну и записать определенную метаинформацию. Никаких вычислений адресов и прочего. Плюс при изменениях в библиотеке, которые не затрагивают API и ABI, можно вообще не перелинковывать исполняемый файл - все изменения подтянутся в рантайме. Линковка-то на самом деле происходит быстрее, но у разделяемых библиотек есть свои недостатки: 👉🏿 оверхэд на инициализацию программы за счет загрузки библиотек 👉🏿 оверхэд на первый вызов каждой функции. Но последующий вызовы уже не имеют заметного оверхэда за счет записей конкретных адресов в таблицу для каждого символа 👉🏿 более сложный деплой. Нужно вместе с бинарником распространять все разделяемые библиотеки. Если используется какой-нибудь докер, то головная боль относительно минимальна А если нет, то есть риски получить конфликты разных версий библиотеки для разных исполняемых файлов(так как все программы, слинкованные с одной шареной либой, обращаются в одному файлу) и увеличение coupling'а между разными программами, использующими одну либу. А вы используете компиляцию модулей своих проектов, как разделяемых библиотек? Share resources. Stay cool. #tools
01 жовт 2025, 06:00

Митап, который становится доброй традицией Открыта регистрация на третью встречу клуба С++ разработчиков 🔥 PVS-Studio совмес
Митап, который становится доброй традицией Открыта регистрация на третью встречу клуба С++ разработчиков 🔥 PVS-Studio совместно с Центральным Университетом организовывают митап "Сплошные плюсы. Клуб С++ разработчиков". Эти встречи не просто про доклады, это уникальная площадка, где вы можете развивать свои профессиональные навыки в приятной атмосфере. Приглашенные спикеры — действующие разработчики, которые понятно объясняют сложные аспекты с практическими примерами. На третьей встрече клуба вас ждут: ⏺ Доклад "Безопасная работа с массивами? Нет, не слышали" Иногда разработчику на С-подобном языке приходит в голову идея использовать двумерный массив как одномерный. Причины для этого всегда разные, а вот результат чаще всего один. Разберём эту сомнительную технику и поговорим о том, какие проблемы она может привнести в вашу программу. ⏺ Квиз++ Проверьте, насколько вы владеете C++ в соревновании для настоящих ценителей языка. Каждый раунд — это новый уровень сложности и адреналина! А ещё — это вкусная пицца, эксклюзивный мерч и классная атмосфера комьюнити, где все свои ❤ Регистрируйтесь по ссылке.
01 жовт 2025, 03:01
05 жовт 2025, ~05:27

include what you use #опытным Еще один способ уменьшить время сборки. Ваша программа может содержать все хэдэры стандартной библиотеки и прекрасно собираться. В чем проблема? Неиспользуемые шаблоны же не компилируются. Не компилируются, но анализируются. Если включить в вашу единицу трансляции кучу ненужных хэдэров, то вся эта куча ненужного кода все равно будет как минимум анализироваться на этапе компиляции на соответствие синтаксису. И на это тратится время. А инклюдятся не только шаблоны, поэтому как максимум в объектный файл могут попасть совершенно неиспользуемые части. Чтобы избежать лишнего анализа, есть такая практика в программировании на С/С++ - include what you use. Включай в код только те заголовочники, где определены сущности, которые вы используете в коде. Тогда не будет тратится время на анализ ненужного кода. У этого подхода есть еще одно преимущество. Если мы полагаемся на неявное включение одних хэдэров через другие, то могут возникнуть проблемы при рефакторинге. Вы вроде был убрали только ненужный функционал вместе с объявлениями соответствующих сущностей, а билд сломался с непонятной ошибкой. Потому что вы убрали источник тех неявно подключаемых заголовков и компилятору теперь их недостает. А мы знаем, какие он "шедевры" может выдавать, если ему чего-то не хватает(тот же пример с std::ranges::less) Как использовать этот подход в проекте? Я знаю пару способов: 1️⃣ Утилита iwyu. Установив ее и прописав зависимости в симейке, на этапе компиляции вам будут выдаваться варнинги, которые нужно будет постепенно фиксить:
# установка

sudo apt-get install iwyu

# интеграция с cmake

option(ENABLE_IWYU "Enable Include What You Use" OFF)

if(ENABLE_IWYU)
    find_program(IWYU_PATH NAMES include-what-you-use iwyu)
    if(IWYU_PATH)
        message(STATUS "Found IWYU: ${IWYU_PATH}")
        set(CMAKE_CXX_INCLUDE_WHAT_YOU_USE "${IWYU_PATH}")
    else()
        message(WARNING "IWYU not found, disabling")
    endif()
endif()

# запуск

mkdir -p build && cd build
cmake -DENABLE_IWYU=ON ..
make 2> iwyu_initial.out

# Анализ результатов
wc -l iwyu_initial.out  # Общее количество предупреждений
grep -c "should add" iwyu_initial.out  # Пропущенные includes
grep -c "should remove" iwyu_initial.out  # Лишние includes
Там есть еще нюансы с 3rd-party, которые мы вынесем за рамки обсуждения. 2️⃣ clang-tidy. Если у вас настроены проверки clang-tidy, то вам ничего не стоит подключить include what you use. Достаточно к проверкам добавить пункт misc-include-cleaner. В конфиге также можно настроить различные исключения, что мы также выносим за скобки обсуждения. В целом, полезная вещь. Помогает меньше связывать модули друг с другом, а также потенциально уменьшает время компиляции. Include what you use. Stay cool. #tools #goodpractice
30 вер 2025, 06:00

​​Несколько советов по написанию быстрого кода от разрабов mold #новичкам Чтобы стать самым быстрым опенсорс-линковщиком, нужно постараться. В результате этих стараний вырабатываются некоторые подходы к написанию производительных приложений, которым разрабочики mold хотели бы с вами поделиться. ✅ Не угадывай, а измеряй Предположения и отрешенные размышления обычно оказываются неверными, поэтому не тратьте время на оптимизацию кода, который не имеет значения. Оптимизируйте самые важные и узкие части. А чтобы их найти, используйте профилировщики, например perf. ✅ Не пытайся писать быстрый код. Вместо этого проектируй структуры данных так, чтобы программа естественным образом становилась быстрее Данные обычно важнее кода. Оптимальная структура данных может дать большее ускорение, чем оптимизация алгоритма. ✅ Реализуй несколько алгоритмов и выбери самый быстрый Одних размышлений недостаточно, чтобы понять, какой алгоритм лучше — просто реализуйте несколько прототипов и сравните их на реальных данных. ✅ Напиши одну и ту же программу несколько раз - Переписывать проект - это нормально. Невозможно и не нужно написать все с первого раза идеально. Это вам скажет почти любой разработчик. Но нужно учиться на первой реализации, затем использовать эти знания для переписывания. - Существуют оптимизации, которые невозможно реализовать без переделки с нуля. - Разработка во второй или третий раз происходит быстрее, поэтому время, потраченное на первую итерацию, не будет полностью потеряно. А какие вы советы дадите по написанию быстрых программ? Be faster. Stay cool. #tool #goodpractice
29 вер 2025, 06:00

⌨️ Ручная компиляция и проекты, привязанные к IDE — это вчерашний день. Если вы хотите уверенно собирать кроссплатформенные C
⌨️ Ручная компиляция и проекты, привязанные к IDE — это вчерашний день. Если вы хотите уверенно собирать кроссплатформенные C++-приложения и масштабировать проекты, без CMake не обойтись. 🗓 30 сентября в 20:00 МСК 🆓 Бесплатно. Урок в рамках старта курса «C++ Developer. Professional». 🦾 На открытом уроке мы разберём основы CMake: создадим минимальный CMakeLists.txt, подключим внешние библиотеки и соберём проект из нескольких файлов. Пошагово, на живых примерах. Вы поймёте, как переводить свои проекты на CMake и почему этот инструмент давно стал стандартом в профессиональной разработке. Эти навыки — must have для любого C++-разработчика, который планирует карьерный рост. 🔗 Ссылка на регистрацию: https://otus.pw/cAZx/ Реклама. ООО «Отус онлайн-образование», ОГРН 1177746618576
29 вер 2025, 03:00
30 вер 2025, ~18:21