es
Feedback

¡No caigas en manos de tramposos! Telemetrio encuentra y marca estos canales 👉 Si quieres ver la etiqueta, suscríbete

Грокаем C++

Грокаем C++

Ir al canal en Telegram

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

Mostrar más
9 357
Suscriptores
+124 horas
+97 días
+2030 días
Archivo de publicaciones
​​Наследие Cfront. Манглирование #новичкам В С нет перегрузки функций, поэтому там люди вынуждены каким-то образом руками разделять имена функций. Вместо
void print(int x);
void print(float x);
Там пишут:
void print_int(int x);
void print_float(float x);
Плюс линкеры работают с именами символов. А имя функции в С не включает в себя параметры. Поэтому во всей программе не может быть двух функций с одинаковыми именами. Линкер их банально не различит и выдаст ошибку множественного определения. А в С++ была перегрузка и надо было каким-то образом плюсовые перегруженные функции превращать в неперегруженные сишные при трансляции кода. Для этого было придумано декорирование имен или name mangling. Самый простой способ - добавлять к конце функции ее параметры в закодированном виде: ИмяФункции_ТипыПараметров:
void draw(int x, int y);
void draw(double x, double y);

// Cfront mangling:
draw_i_i          // draw(int, int)
draw_d_d          // draw(double, double)  
Так как у нас не может быть двух перегрузок с разными возвращаемыми значениями, то кодирование типа возврата не нужно. Но это самое базовое представление о декорировании имен. Давайте посмотрим, что еще может влиять на итоговое имя функции: 👉🏿 2 разных класса могут иметь методы с одинаковым названием. Так как при трансляции в С это были просто свободные функции, манглинг должен учитывать и имя класса:
void Circle::paint(Color c);
void Square::paint();
Rectangle::~Rectangle();
Shape::~Shape();

// transform into

void Circle_paint_Color(struct Circle* this, Color c);
void Square_paint(struct Square* this);
void Rectangle_dtor(struct Rectangle* this);
void Shape_dtor(struct Shape* this);
👉🏿 Есть же еще и пространства имен. Они помогают разграничить скоуп существования имен. И названия пространства имен тоже манглировались в имена функций:
namespace Graphics {
    class Canvas {
        void clear();
    };
}

// transform into

void Graphics_Canvas_clear(struct Canvas* this)
👉🏿 В С++ когда-то появились шаблоны. Шаблон всегда инстанцируется с каким-то типом. И чтобы различать эти инстанциации, Cfront манглировал типы шаблонных параметров в полное имя типа:
template<typename T>
class Stack {
    void push(T value);
};

Stack<int> stack;

// transforms into

Stack_int_push_i(int value);
Конкретные преобразованные имена из поста могут быть не такими, какими их генерировал Cfront, но главное уловить идею. В современных компиляторах тоже делается манглинг имен, чтобы линкер не ругался на одинаковые символы:

void Circle::rotate(int);

// transforms into 

_ZN6Circle6rotateEi

// Разбор:
_Z                   - префикс C++
N                    - вложенное имя
6Circle              - длина=6, "Circle"  
6rotate              - длина=6, "rotate"
E                    - конец аргументов
i                    - тип int
Шаблоны, неймспейсы, noexcept и const квалификаторы - все вшивается в имя символа. Вы также можете вручную управлять манглингом: включать и выключать его:
extern "C" void c_function();   // Без манглинга: _c_function
extern "C++" void cpp_function(); // С манглингом: _Z10cpp_functionv
Это нужно для совместимости ABI интерфейсов, предоставляемых библиотеками. Поэтому декорирование имен живее всех живых и повсеместно используется в современных компиляторах. Have a legacy. Stay cool #cppcore #goodoldc #compiler
27 dic 2025, 05:00

​​Компилятору достаточно лишь правильно положить аргументы функции в правильные регистры, согласно calling conventions. Какие аргументы нужно подготовить компилятор знает заранее, так как сигнатура виртуальных методов одинакова для всех переопределенных вариантов. Остается лишь call'ьнуть нужный указатель и происходит виртуальный вызов. Подкапотоное устройство полиморфизма часто спрашивают на собесах. Теперь вы знаете, как отвечать почти на полный спектр вопросов по этой теме. Know whats under the hood. Stay cool. #compiler #cppcore
25 dic 2025, 05:00

Современные таблицы виртуальных функций #опытным С++ давно ушел от компиляции в С. Но таблицы виртуальных функций, как средство реализации динамического полиморфизма, остались в компиляторах. Как устроены vtables сейчас, когда С++ напрямую компилируется в ассемблер? Идея все та же: 👉🏿 На каждый полиморфный класс создается своя vtable 👉🏿 Она представляет собой просто массив адресов. В ассемблере адреса нетипизированные, поэтому они просто лежат там чиселками. 👉🏿 В каждом объекте хранится vptr - указатель на эту таблицу. 👉🏿 vtpr инициализируется в самом базовом классе его адресом его vtable и затем каждый конструктор наследника присваивает в него адрес своей таблицы Реализации вносят свои особенности, но это ядро остается неизменным. Вот примерчик(можете смотреть на годболте):
class Person {
protected:
    std::string name;
    int age;
public:
    Person(const std::string &n, int a) : name(n), age(a) {}
    virtual std::string getRole() const { return "Person"; }
    virtual std::string getName() const { return name; }
    virtual void describe() const {
        std::cout << name << " (" << age << " years)";
    }
    virtual ~Person() = default;
};

class Employee : public Person {
    std::string position;
public:
    Employee(const std::string &n, int a, const std::string &pos)
        : Person(n, a), position(pos) {}
    std::string getRole() const override { return "Employee"; }
    void describe() const override {
        std::cout << name << " (" << age << " years) - " << position;
    }
};

int main() {
    Person * p = new Employee("Steven", 42, "CEO");
    p->describe();
    std::cout << p->getName() << std::endl;
}
Будем сейчас разбирать gcc-шный асм. Вот так выглядят таблицы для обоих классов:
vtable for Person:
.quad 0
.quad typeinfo for Person
.quad Person::getRoleabi:cxx11 const
.quad Person::getNameabi:cxx11 const
.quad Person::describe() const
.quad Person::~Person()

vtable for Employee:
.quad 0
.quad typeinfo for Employee
.quad Employee::getRoleabi:cxx11 const
.quad Person::getNameabi:cxx11 const
.quad Employee::describe() const
.quad Employee::~Employee()
quad - это 64-битное число. Видно, что таблицы - это статические массивы. Первым числом у них является offset to top, это число нужно для корректной работы множественного наследования, не будем вдаваться в детали. Второй число - адрес расположения информации о динамическом типе(RTTI) объекта. Эта информация нужна, например, для dynamic_cast'а. Дальше расположены адреса виртуальных функций нужных классов. Заметьте, что адреса расположены в порядке объявления виртуального метода в классе. Если в дочернем классе переопределяется метод, то в его vtable указатель родительского метода заменяется на переопределенный(методы getRole и describe). Если наследник не переопределяет метод, то в таблице остается указатель на родительский метод(getName). В конструкторе Employee происходит такое:
; Сначала вызывается конструктор Person (устанавливает vptr Person)
call    Person::Person(...) [base object constructor]

; Затем перезаписывается vptr на таблицу Employee
mov     edx, OFFSET FLAT:vtable for Employee+16
mov     rax, QWORD PTR [rbp-24]
mov     QWORD PTR [rax], rdx
Вызывается конструктор базового класса и сразу же после этого переприсваивается vptr на таблицу класса Employee. Ну а виртуальный вызов выглядит просто как call нужного адреса:
mov     rax, QWORD PTR [rbp-40]    ; Загружаем указатель p
mov     rax, QWORD PTR [rax]       ; Загружаем vptr (указывает на vtable+16)
add     rax, 16                    ; Смещаемся к 4-му слоту (describe)
mov     rdx, QWORD PTR [rax]       ; Загружаем адрес функции describe
mov     rax, QWORD PTR [rbp-40]    ; Загружаем this (указатель p)
mov     rdi, rax                   ; Передаем this как первый параметр
call    rdx                        ; Виртуальный вызов describe
25 dic 2025, 05:00

🧑‍💻Если вы давно смотрите в сторону разработки, но не нашли язык, который даст реальную глубину, масштаб и перспективы — C+
🧑‍💻Если вы давно смотрите в сторону разработки, но не нашли язык, который даст реальную глубину, масштаб и перспективы — C++ остаётся одним из немногих способов «вкатиться в IT» так, чтобы фундамент работал на вас долгие годы. Мы создали путь от полного нуля до уровня Middle — через проектную работу, живые разборы и практику, которая показывает, что происходит под капотом. Вы научитесь работать с типами, памятью, потоками выполнения и экосистемой C++. Освоите современные стандарты 11–23, корутины, Boost, STL, сетевое взаимодействие и т.д. 🎄Новогодние подарки от OTUS для вас! Приобретайте 3 курса с выгодой до 30%! Покупая 1 курс вы получаете 15%, 2 курса - 25% скидки, 3 курса - максимальную скидку в 30%. Заморозьте цены на обучение! Предложение действует до 26 декабря 2025 года. 💫Старт совсем скоро! Оставьте заявку: https://otus.pw/kT1a/ Реклама. ООО «Отус онлайн-образование», ОГРН 1177746618576
25 dic 2025, 02:00
29 dic 2025, ~03:28

​​Наследие Cfront. Полиморфизм #новичкам Часто мы говорим о каких-то вещах в С++ и можем сказать, как они работают под капотом. Но стандарт языка не говорит о том, как компиляторы должны реализовывать те или иные фичи. Он только задает требование. Тем не менее подходы к реализации некоторых фичей повторяются в разных компиляторах. И отчасти это так из-за влияния Cfront. В С++ классический динамический полиморфизм подтипов синтаксически реализуется через виртуальные функции.
class Person {
protected:
    std::string name;
    int age;

public:
    Person(const std::string &n, int a) : name(n), age(a) {}

    virtual void describe() const {
        std::cout << name << " (" << age << " years)";
    }

    virtual ~Person() = default;
};

class Employee : public Person {
    std::string position;

public:
    Employee(const std::string &n, int a, const std::string &pos)
        : Person(n, a), position(pos) {}

    void describe() const override {
        std::cout << name << " (" << age << " years) - " << position;
    }
    ~Employee() override = default;
};
Мы более подробно разбирали полиморфизм в одном из предыдущих постов. Сейчас мы поговорим, как примерно Cfront преобразовывал этот С++ код в С код. Основные идеи: 1️⃣ Для каждого полиморфного класса формируется статическая таблица виртуальных функций. Это по сути массив указателей на виртуальные "методы" класса, которые Cfront представлял в виде обычных функций. Порядок методов в таблице определялся порядком их объявления в классе. 2️⃣ Нужно каким-то образом связать таблицу для класса с объектом этого класса. Для этого использовалось неявное дополнительное поле класса - указатель на таблицу виртуальных функций или vptr. Вот как Cfront преобразовывал код выше(примерно, детали могут отличаться):
struct Person {
    // pointer to vtable
    void (**vptr)();
    struct string name;
    int age;
};

struct Employee {
    struct Person base;
    struct string position;
};
В самом первом базовом классе появлялся указатель vptr, который в конструкторе инициализируется правильным адресом нужной таблицы. void (**vptr)() - это тип указателя на указатель на функцию, возвращающую void и не принимающую аргументов. Но погодите, виртуальные методы как минимум принимают один неявный аргумент this, а как максимум могут самые разнообразные сигнатуры иметь. Почему указатель имеет такой тип? Ну а как вы еще засунете в один массив разные функции? Их кастили к одному общему типу void(*)(), только так это было возможно:
void (*Person_vtable[])() = {
    (void(*)())Person_describe_impl,
    (void(*)())Person_dtor
};

void (*Employee_vtable[])() = {
    (void(*)())Employee_describe_impl,
    (void(*)())Employee_dtor
};

void Person_describe_impl(const struct Person* this) {
    printf("%s (%d years)", this->name, this->age);
}

void Person_dtor(struct Person* this) {
    String_dtor(this->name);
}

void Employee_describe_impl(const struct Person* this) {
    // cast to proper type
    const struct Employee* emp = (const struct Employee*)this;
    printf("%s (%d years) - %s", emp->base.name, emp->base.age, emp->position);
}

void Person_dtor(struct Person* this) {
    String_dtor(this->position);
    Person_dtor(this->base);
}
Cfront генерировал Сишные реализации методов и клал их в массив, попутно приводя к типу void(*)(). Ну а в месте вызова метода компилятору ничего не мешает сделать каст к нужному типу, так как он знает сигнатуру вызываемого метода:
void print_info(const Person* person) {
    person->describe();
}
void print_info(const struct Person* person) {
    void (*describe_func)(const struct Person*) = 
        (void (*)(const struct Person*))person->vptr[0];
    describe_func(person);
}
В те времена С не был стандартизирован и правила преобразования типов были несколько мягче, поэтому такая магия с приведениями работала. В наше время не нужна трансляция С++ в С, но тем не менее концепция таблиц виртуальных функций и указателей на них осталась. Have a legacy. Stay cool #cppcore #goodoldc #compiler
23 dic 2025, 04:00

​​Наследие Cfront. Наследование #новичкам Сорри за тавталогию, но мимо этой темы мы не можем пройти(хотя я бы прошел, если бы не @shumilkinad, спасибо ему) В раннем С++ уже были классы и наследование, но в С этого не было. Как же можно транслировать наследование классов в С'шный код? Простая агрегация и никакого мошенничества. Все классы в С++ - это простые С-структуры с отдельным набором функций, принимающих cv-специфицированный указатель на инстанс структуры(это мы выяснили в прошлом посте). Наследники же в начале объекта хранят все поля базового класса. Так давайте просто первым полем наследника сделаем инстанс базовой структуры. Таким образом мы обеспечим вложенность объектов с любым количеством наследований. Вот есть пара родитель-наследник:
class Base {
public:
    int x;
    Base(int a) : x(a) {}
};

class Derived : public Base {
public:
    int y;
    int z;
    Derived(int a, int b) : Base(a), y(b) {
    z = x + y;
  }
};
Примерно в такой код они транслировались:
struct Base {
    int x;
};

struct Derived {
    struct Base _base;  // embedded base object
    int y;
    int z;
};

void Base_constructor(struct Base* this, int a) {
    this->x = a;
    
    // Constructor body (if presented)
}

void Derived_constructor(struct Derived* this, int a, int b) {
    // Init base object
    Base_constructor(&this->_base, a);
    
    // Init fields of derived object
    this->y = b;
    
    // Constructor body
    this->z = this->_base.x + this->y;
}
Первым полем структуры Derived - структура Base. Конструкторы же - это отдельные функции. Но в С++ очень важен порядок вызовов конструкторов и деструкторов. Поэтому конструктор самого базового класса только инициализирует свои поля и дальше выполняет инструкции из тела конструктора. При создании же наследников в начале вызывается конструктор базового класса и лишь потом инициализация полей и выполнение тела. Разрушение же объекта выполняется в обратном порядке. Трусы снимаются только после штанов, раньше не получится.
class Base {
public:
    ~Base() { 
        // Destructor Base body
    }
};

class Derived : public Base {
public:
    ~Derived() {
        // Destructor Derived body
    }
}
Превращается в:
struct Base {
};

struct Derived {
    struct Base _base;

};

void Base_destructor(struct Base* this) {
    // Destructor Base body
}

void Derived_destructor(struct Derived* this) {
    // Destructors execute in reverse order
  
    // Destructor Derived body
    
    Base_destructor(&this->_base);
}
Новичкам особенно будет полезно понимать, как простой код С++ может быть написан на С, чтобы досканально понимать все абстракции языка и какие действия скрыты от наших глаз. Have a legacy. Stay cool. #cppcore #goodoldc #compiler
22 dic 2025, 05:00

🚀Ваш код работает — но мог бы быть быстрее. Проблема не всегда в алгоритме: зачастую узкое место в том, как процессор работа
🚀Ваш код работает — но мог бы быть быстрее. Проблема не всегда в алгоритме: зачастую узкое место в том, как процессор работает с памятью. Кэш, страницы, выравнивание — всё это влияет на скорость сильнее, чем кажется на первый взгляд. На открытом вебинаре вы разберётесь, что такое cache friendly код и почему грамотная работа с памятью может ускорить вашу программу в разы. На примерах покажем, как устроено взаимодействие с кэшами, где теряется производительность и как это исправить. Вы узнаете, как анализировать поведение памяти и превращать идеи в эффективный, предсказуемый C++-код. ⚡️23 декабря в 20:00 МСК. Открытый урок проходит в преддверии старта курса «C++ Developer. Professional». Регистрация открыта: https://otus.pw/9Fz7/ Реклама. ООО «Отус онлайн-образование», ОГРН 1177746618576
22 dic 2025, 02:00
29 dic 2025, ~03:28

​​Наследие Cfront. this #новичкам Cfront был первым компилятором С++. И это оказало большое влияние на то, какие подходы к компиляции C++ используют другие компиляторы. В следующих нескольких постах мы обсудим наследие, которое после себя оставил Cfront. Главное, о чем надо помнить в этой серии - Cfront компилировал С++ код в С. То есть все концепции языка С++, которыми Cfront оперировал, можно было представить в С коде. Некоторые такие представления перетекли в стандарт, некоторые остались на уровне реализации. Сегодня поговорим про такую привычную и базовую вещь, как this или неявный указатель на объект класса в методах. Мы уже написали несколько постов о том, как можно вызывать методы классов с помощью указателя на функцию и объекта класса(или указателя на него). Тык, тык и тык. Но здесь повторим более наглядно чтоли. Вот у Cfront на входе есть С++ код:
class Point {
    int x, y;
public:
    Point(int x, int y) : x(x), y(y) {}
    int get_x() const { return x; }
    int get_y() const { return y; }
    void move(int dx, int dy) { x += dx; y += dy; }
};
У каждого класса есть конструктор, деструктор и набор методов. Все это компилировалось в обычные функции, которые первым аргументом принимали неявный указатель this на экземпляр сишной структуры:
struct Point {
    int x;
    int y;
};

void Point_ctor(struct Point* this, int x, int y) {
    this->x = x;
    this->y = y;
}

int Point_get_x(const struct Point* this) {
    return this->x;
}

int Point_get_y(const struct Point* this) {
    return this->y;
}

void Point_move(struct Point* this, int dx, int dy) {
    this->x += dx;
    this->y += dy;
}

void Point_dtor(struct Point* this) {}
Константность метода регулировалась константностью указателя this. Если есть класс, значит должно быть использование:
void foo() {
  Point p = Point(1, 2);
  p.move(2, 3);
  printf("%d/n", p.get_x());
}
Этот код превращался в нечто подобное:
void foo() {
  struct Point p;
  Point_ctor(&p, 1, 2);
  Point_move(&p, 2, 3);
  printf("%d/n", Point_get_x(&p));
  Point_dtor(&p);
}
Заметьте, что в конце любого скоупа, в котором был создан объект компилятором вставлялся вызов деструктора, тем самым обеспечивая идиому RAII. Have a legacy. Stay cool. #cppcore #goodoldc #compiler
21 dic 2025, 04:00

​​История компилятора С++ #новичкам С++ начал свой путь в 1979 году, когда Бьерн Страуструп работал над своей диссертацией. Он назвал его "С с классами". Это была довольно примитивная версия С++, были просто добавлены классы, их методы, возможность наследования и другие более минорные фичи. Никакого полиморфизма и шаблонов. Для компиляции этой версии было достаточно написать препроцессор для С компилятора, который бы транслировал инструкции С++ в С-шный код. Этот препроцессор + С-компилятор назывался CPre. Но Бьерн не забросил свою разработку и в 1982 году разработал улучшенную версию С с классами и назвал ее С++. Она уже включала виртуальные функции, перегрузку функций и операторов, ссылки, стандартные функции работы с памятью(new/delete). И CPre уже не справлялся с такими мощными фичами. Да он и изначально был довольно костыльным, потому что не было работы с типами, которой быть и не могло на этапе препроцессинга. Нужно было делать лексический и синтаксический анализ, строить ast дерево программы, чтобы поддерживать типобезопасность. Но хотелось сохранить возможность получения С-шного кода из С++, потому что это способствовало более быстрому распространению языка и его можно было использовать в новых модулях старых проектов. По сути нужен был полноценный компилятор, преобразующий С++ код в С. И им стал Cfront. Вот теперь пошли интересности. Первая простейшая версия языка С++ и компилятора Cfront была написана на "С с классами" и скомпилирована CPre. В дальнейшем мощные фичи в язык добавлялись уже с помощью Сfront, который писался на предыдущей версии С++. CPre не вывозил возросшей сложности. Ну хорошо, Бьерн у себя на домашнем компьютере с определенной архитектурой имеет свежайшую версию Cfront, которая написана на С++. С++ уже не может быть скомпилирован CPre. Как получить компилятор на другой архитектуре? Здесь помогла именно трансляция С++ в С код. При компиляции свежей версии Cfront на выходе на самом деле получается Сшный код. Если этот код чуть причесать и убрать оттуда платформозависимые решения, то можно принести его на компьютер с другой архитектурой, скомпилировать его существующим там С-компилятором и получить готовый Cfront, умеющий компилировать С++. Таким образом распространялись версии компилятора под разные архитектуры. Cfront успешно развивался еще несколько лет, но у него были объективные недостатки: 👉🏿 скорость компиляции в С/С++ и так не славится скорость, так тут еще и двухступенчатая компиляция была 👉🏿 при попытке компиляции ошибки показывались в сгенерированном C-коде, а не в исходном C++, что затрудняло отладку 👉🏿 некоторые возможности C++ было сложно или невозможно реализовать через трансляцию в C. С не всесилен и довольно лаконичен в используемых инструментах. В итоге при попытке добавить в язык исключения Cfront умер... Но благо разработчики прониклись С++ и поняли, что для быстрой и полноценной работы с С++ им нужен полноценный компилятор С++ в асм. Ну а дальше начал разрастаться зоопарк плюсовых компиляторов, некоторые умирали, а некоторые дожили до наших дней. The end. Know that everything has its limits. Stay cool. #tools #compiler
19 dic 2025, 11:00

🔍 Вебинар перед курсом «Программист С»: разберём устройство памяти в С до мельчайших деталей Приглашаем на практический веби
🔍 Вебинар перед курсом «Программист С»: разберём устройство памяти в С до мельчайших деталей Приглашаем на практический вебинар для тех, кто пишет код всерьёз. Урок для embedded‑разработчиков, системные администраторов разработчиков на C++. На вебинаре разберём: - как устроен процесс на уровне секций памяти; - чем отличаются стек и куча — и где лучше размещать данные; - как ОС выделяет память и что происходит при вызове malloc(); - что делают системные вызовы brk()/sbrk(); - как free() «узнаёт», сколько памяти высвободить. Что вы получите: - чёткое понимание устройства стека и кучи; - критерии выбора: когда использовать стек, а когда — кучу; - практические навыки работы с динамической памятью — без утечек и ошибок. Почему это важно? Без понимания механизмов управления памятью даже опытный разработчик может столкнуться с: - утечками памяти; _ segmentation fault; - непредсказуемым поведением программы. 📅 Дата: 15.01.2026 в 20:00 👉 Регистрируйтесь сейчас: https://otus.pw/71NX/ Вебинар проходит в преддверии старта курса «Программист С» и для тех, кто рассматривает обучение, мы подготовили специальное предложение. 🎄 Учитесь в новом году по старым ценам! Максимальная скидка 30% на обучение до 21.12.2025: 1 курс — тающая скидка 15% до 21.12 2 курса −25%, 3 курса −30% Вы можете оставить заявку на странице курса. Учиться системно — выгоднее! Реклама. ООО «Отус онлайн-образование», ОГРН 1177746618576
19 dic 2025, 08:05
23 dic 2025, ~08:05

​​Bootstrap #новичкам Если вы когда-нибудь заходили в исходники своего компилятора, то могли заметить, что его исходный код написан на С++. Также возможно вы слышали, что компилятор java написан на java. Если вдуматься в эти факты, то невольно задаешься вопросом: а как это вообще возможно? Нельзя же себя поднять за волосы из болота. Вообще-то барон Мюнхгаузен смог и мы сможем! Нужно лишь немного опоры. Чуть-чуть оттолкнуться. Давайте пройдем весь процесс от и до. 1️⃣ Вы решили написать свой язык самый лучший язык во всей вселенной GOAT. Разработали синтаксис и правила языка, пару раз пооргазмировали от его крутости. 2️⃣ Дальше вам нужно уметь конвертировать код на новом языке в программу. Выхода нет: вы быстренько пишите простой компилятор или интерпретатор GOAT на уже существующем языке. Пусть для определенности вы написали компилятор на С. Компилируете его каким-нибудь gcc и у вас появляется первый компилятор языка GOAT. Это так называемый компилятор начальной загрузки или bootstrap компилятор. Отлично! Вы можете писать программы на новом языке! 3️⃣ Но компилятор - это же тоже программа. Теперь вы можете на GOAT написать компилятор GOAT и скомпилировать его bootstrap компилятором. В итоге у вас получится рабочий компилятор GOAT, написанный на языке GOAT! Вот яйцо и родило яйцо. 4️⃣ В дальнейшем вы можете развивать компилятор, используя сам язык GOAT и перекомпилируя его самим собой. Весь этот процесс называется bootstrapping. Первый компилятор и jvm были написаны на С. Первый компилятор С был написан на ассемблере. Pascal'я - на Fortran. Интересно, что clang изначально был написан на урезанной версии С++, которая компилировалась и на gcc, и на msvc. Поэтому clang можно использовать на винде. Преимущества бутстраппинга: 👉🏿 Демонстрирует зрелость и самодостаточность языка. Можно развиваться самостоятельно и не зависеть от других технологий. 👉🏿 Разработчики компилятора могут использовать все возможности языка, для которого они пишут компилятор. 👉🏿 Тестирование возможностей языка. Если вам недостаточно инструментов в языке, чтобы написать компилятор, значит язык нужно дорабатывать. 👉🏿 Упрощается разработка компилятора. Не нужно знать несколько языков. А вот как бутстрапился С++ разберем в следующем посте. Be self-sufficient. Stay cool. #tools #compiler
18 dic 2025, 05:00

Как запустить cpp файл из консоли? Да, да, именно запустить файл. Берете bash, берете файл. Как одно воткнуть в другое и получить результат работы программы? Следите за пальцами:
#if 0
g++ test.cpp -o test
./test
exit 0
#endif

#include <iostream>

int main() {
    std::cout << "Hello, World!" << std::endl;
}
Есть ли мы попытаемся запустить файл с этим содержимым через терминал, то будет выполняться следующая последовательность шагов: 1️⃣ Ядро смотрит на первые 2 байта файла и пытается найти там шебанг - #!. Если нашла, то в этой строчке будет указан путь до нужного интерпретатора. 2️⃣ Если шебанга нет и файл не является исполняемым(как у нас), то файл считается shell-скриптом и исполняется с помощью текущего командного интерпретатора. 3️⃣ Для shell-скриптов символ # обозначает начало однострочного комментария, поэтому первая строчка игнорируется. 4️⃣ Интерпретатор встречает команду компиляции и выполняет ее. 5️⃣ Теперь мы пытаемся реально скомпилировать этот файл с помощью g++. На этапе препроцессинга ветка условия #if 0 выбросится из текста файла и компилироваться будет только реально С++ код. 6️⃣ После компиляции интерпретатор запускает исполняемый файл и завершает работу на инструкции exit 0. Остальной С++ код он уже не увидит. Напишите в терминале
chmod +x test.cpp
./test.cpp
И увидите заветные слова. Дожили! Превратили С++ в питон... PS: Большое спасибо за идею и материалы Даниилу @dkay7. Have a fun. Stay cool. #fun
17 dic 2025, 05:00

🎯 В C++ вызываемый объект — это намного больше, чем “функция”. За тридцать лет язык прошёл путь от простых указателей до мощ
🎯 В C++ вызываемый объект — это намного больше, чем “функция”. За тридцать лет язык прошёл путь от простых указателей до мощных лямбда-выражений, которые лежат в основе современного параллелизма, асинхронности, алгоритмов и гибких архитектур. На открытом уроке 18 декабря в 20:00 мск вы увидите эволюцию callable-подходов во всей широте: от function pointers и функторов до std::bind, std::function и современных лямбд. Разберёмся, что происходит «под капотом», как выбирать подходящий инструмент и почему именно лямбды стали стандартом промышленного C++. Такой разбор особенно полезен тем, кто хочет писать более выразимый, модульный и безопасный код. Понимание callable-моделей даёт гибкость: проще проектировать API, реализовывать callback-механику, строить асинхронность, оптимизировать архитектуру приложения и мыслить “по-современному”. ⚡️Присоединяйтесь к открытому уроку в преддверие старта курса «C++ Developer» — получите базу, на которой строятся потоки исполнения, асинхронные модели и ключевые элементы современного C++20/23: https://otus.pw/cY5r/ Реклама. ООО «Отус онлайн-образование», ОГРН 1177746618576
17 dic 2025, 02:01
20 dic 2025, ~06:53

​​Мок собеседования #новичкам #опытным Представьте, что вы вкатун в АйТишку плюсовую. Прочитали несколько книжек, прошли кучу бесплатных курсов и дописали свой первый велосипед пет-проект. Пора бы попробовать устроиться на работу. Но учеба и учебные проекты - это одно, а собеседования - это совсем другое. Надо знать, как их проходить, это отдельная наука. Но как узнать, как проходить собесы, если никогда их не проходил?(оставим за скобками вопрос, как вообще добраться до собеса, это то еще шаманство) Для этого существуют мок-собеседования. То есть дословно "имитация" собеседования. В идеале его проводить с живым человеком, например вашим ментором или любым другим опытным чуваком, который изъявляет желание. Но если вы стеснительный волк-одиночка, к тому же еще и бедный(за занятия с ментором нужно платить), то и для вас есть вариант. В сети лежит куча готовых мок-собеседований по С++ на позиции разных уровней. На самом деле видео мок-собесов - не бомже-вариант, а маст хэв для любого человека, неуверенного в своих скиллах прохождения собеседований. Весь из себя сеньор, выходивший на рынок 10 лет назад, тоже скорее всего для себя что-то подчерпнет. Даже в русскоязычном пространстве можно найти много таких видосов. Основные мок-интервьюеры у нас это: - Ambushed raccoon - Владимир Балун Ну а мы за вас собрали подборку всех(или почти всех) мок-собесов на русском языке по С++ и разбили их по уровням. Junior: - https://www.youtube.com/watch?v=_-EkLLZ5svk - https://www.youtube.com/watch?v=H1mIHJxnm9E - https://www.youtube.com/watch?v=PQ1C_0EAHFI - https://www.youtube.com/watch?v=BCpHj698D8U - https://youtu.be/7g8HufwNa0g?si=XVKRsuoHN20MJx3i - https://youtu.be/a18qTcWn-II?si=OttfqKh0bHLjueOY - https://www.youtube.com/live/rLOgkn6xVQA?si=lFqwGf_Wsr8IohHo - https://youtu.be/VfoxaNLVtmQ?si=elt-OyZWB5tXp5hI Middle: - https://www.youtube.com/watch?v=nMdNehH8-Ss - https://www.youtube.com/watch?v=Ed37R0FvkQ8 - https://www.youtube.com/watch?v=IDqMy4_xkb4 - https://www.youtube.com/watch?v=BOUEbS5L4-8 - https://www.youtube.com/watch?v=PwVMcxCBIkg - https://www.youtube.com/watch?v=Np6UrKN6ZbA - https://www.youtube.com/watch?v=1Ez3kbK_3bI - https://www.youtube.com/watch?v=s6BXbEPaw5g - https://www.youtube.com/watch?v=yfoFtu28n4o - https://www.youtube.com/watch?v=cT3fonCyxJk - https://www.youtube.com/watch?v=xwb2FAKxCUo - https://www.youtube.com/watch?v=bOgz4K-ARzQ - https://www.youtube.com/watch?v=wR4VRCp_BYo - https://youtu.be/5enBKMwOST0?si=i-5mdyrxeeFiZKo1 Senior: - https://www.youtube.com/watch?v=OwMEK_W8Ysw - https://www.youtube.com/watch?v=dZpe58HKX-8 Просто вопросы и задачи с собесов: - https://www.youtube.com/watch?v=boYk6gFg84E - https://www.youtube.com/watch?v=ViHNB0_1j90 - https://www.youtube.com/watch?v=aYM7lksQ8yg - https://www.youtube.com/watch?v=UdY_YMFx7SY - https://www.youtube.com/watch?v=PStQ4jhhz08 - https://www.youtube.com/watch?v=wMYfg_iPqMQ Просмотрев эти видосы(возможно по нескольку раз) и переписав ответы на все вопросы себе в тетрадочку или файлик, вы будете знать ответы на 95% устных вопросов, которые вам будут задавать в условной компании Х. Возможно вы не все будете до конца понимать, но уж очень глупых ошибок точно не совершите. Ну а для любителем native english есть канал Кодингового Иисуса. Он постоянно у себя на стримах спрашивает у людей за плюсы. В основном люди валятся на простых вопросах, но иногда попадаются качественные собеседники. По крайней мере практика языка вам будет точно обеспечена. Еще раз. Смотреть эти видосы можно(и почти нужно) примерно всем, кто задумывается о смене работы. Кому-то вспомнить, кому-то заполнить пробелы, кому-то понять, что все совсем плохо и садиться учить базу. Каждый найдет себе занятие по душе. Practice makes perfect. Stay cool. #interview
14 dic 2025, 04:00

Парсим ужас #новичкам Вот мы и рассмотрели все необходимые компоненты, чтобы понять, что написано здесь:
[[]][[]]int main()[[]]{{[][][[]][[]]{{{}}}(main);}}
Если включить clang-format, то код преобразится во что-то такое:
/*1*/[[]][[]] int main()/*2*/[[]] {
    {
        []/*3*/[[]](/*4*/[[]] /*5*/auto [])/*6*/[[]][[]] {
            {
                {}
            }
        }/*7*/(main);
    }
}
Давайте посмотрим, откуда так много скобок: 1️⃣ Перед типом возвращаемого значения main определены 2 пустые области для указания атрибутов функции main. 2️⃣ Перед телом функции main определена пустая область для атрибутов, применяемых к типу функции main. 3️⃣ После блока захвата лямбды определена пустая область для атрибутов, применяемых к самой лямбде. 4️⃣ Внутри списка параметров лямбды определена пустая область для атрибутов, применяемых к единственному параметру лямбды. 5️⃣ Сама лямбда является generic и принимает массив неизвестного типа. 6️⃣ Перед телом лямбды определены 2 пустые области для атрибутов, применяемых к типу лямбды. 7️⃣ Вызываем лямбду с помощью указателя на функцию main. 8️⃣ Ну и разбавили это дело несколькими лишними скоупами по пути. Не так уж и сложно оказалось) Так, новичковая часть закончилась. #опытным Интересно, что этот код компилируется на gcc, но не на clang. cppinsights показывает, что лямбда раскрывается во что-то такое:
class __lambda_5_17 {
public:
    template <class type_parameter_0_0>
    inline /*constexpr */ auto operator()(auto *) const {
        { {}; };
    }

private:
    template <class type_parameter_0_0>
    static inline /*constexpr */ auto __invoke(auto *__param0) {
        return __lambda_5_17{}.operator()<type_parameter_0_0>(__param0);
    }

public:
    // /*constexpr */ __lambda_5_17() = default;
};
То есть по факту мы имеем шаблонный оператор с auto параметром. Как интерпретировать эту штуку - дело нетривиальное и по ходу компиляторы это делают по-разному. Видимо gcc при попытке инстанцировать шаблон с параметром int() выводит auto как тот же самый тип функции int() и в итоге лямбда принимает указатель на функцию. А clang при попытке инстанцировать шаблон выводит тип параметра функции как массив функций int() и не может принять main в качестве такого параметра. Пишите ваше мнение, кто прав, кто виноват) Deal with horrible things step by step. Stay cool. #cppcore #compiler
11 dic 2025, 12:00

Яндекс приглашает на встречу РГ21 С++ 15 декабря в Москве Собираемся сообществом экспертов и энтузиастов С++, чтобы обсудить
Яндекс приглашает на встречу РГ21 С++ 15 декабря в Москве Собираемся сообществом экспертов и энтузиастов С++, чтобы обсудить развитие стандарта, участие российских разработчиков в нем, а еще — внезапные новинки. В центре встречи — выступление Антона Полухина, руководителя группы разработки общих компонентов в Яндексе. Он поделится новостями с последней встречи международного Комитета по стандартизации, расскажет о прогрессе в работе над С++26 и ответит на вопросы о том, как российским разработчикам участвовать в развитии стандарта языка. Когда: 15 декабря, 18:30 Где: Москва, офлайн + онлайн-трансляция Регистрация на встречу
11 dic 2025, 09:00
23 ene, ~05:17

​​Множество атрибутов #опытным Если вы хотите указать несколько атрибутов для вашей функции, вы можете использовать следующий синтаксис: 1️⃣ Списочный. Внутри одних скобок перечисляете все атрибуты:
[[gnu::always_inline, gnu::const, gnu::hot, nodiscard]] int f();
2️⃣ Многоскобочный. Для больших любителей распиленных квадратов. Очень больших:
[[gnu::always_inline]] [[gnu::hot]] [[gnu::const]] [[nodiscard]] int f();
Больше квадратных скобок! Также если вы используете несколько атрибутов из какого-то одного неймспейса, то можете использовать директиву using:
[[using gnu : always_inline, const, hot]] [[nodiscard]] int f();
Но тогда котлеты отдельно, мухи отдельно. Все атрибуты одного неймспейса нужно уносить в отдельные скобки. Это фича С++17. Что интересно, вы можете написать полную чупуху:
[[rust, will, replace, cpp]] int f();
И это скомпилируется! Стандарт поддерживает любые implementation-defined атрибуты. Причем неизвестные атрибуты просто игнорируются. Правда игнор спровождается варнингами, которые тем не менее можно скрыть опциями, подобным -Wno-attributes. Таким образом, если ваш код компилируется под разные системы, то вы можете не стесняясь использовать дублирующие атрибуты, предоставляемые разными компиляторами. Так на любой платформе можно получить одинаковое поведение. Love squares. Stay cool. #cppcore #cpp17
10 dic 2025, 05:00

​​Атрибуты параметров функции #новичкам Атрибуты можно также применять к параметрам функции. Это помогает чуть полнее в коде функции аннотировать некоторые свойства параметров.
class Interface {
public:
    virtual void method(int param) = 0;
};

class Implementation : public Interface {
public:
    void method(int param) override {
        // this implementation doesn't use param so mark it
    }
};
Вы определили какой-то интерфейс с методом, принимающим один параметр. И в какой-то момент появилась необходимость создать наследника, реализующего этот интерфейс, однако реализации не нужен параметр param. Возможно Implementation - это какой-то мок, у которого в принципе пустая реализация. Если вы активно используете варнинги компилятора и прочие линтеры, при попытке собрать такой код вы скорее всего увидите предупреждение/ошибку компиляции. Чтобы ее стало все чётенько, стоит пометить param атрибутом maybe_unused, тем самым явно указав компилятору, что параметр не используется намеренно. И проблема исчезнет. Однако из стандартных атрибутов по сути имеет смысл использовать только этот самый maybe_unused. Но атрибуты - это не только средство общения с компилятором. Это еще и средство налаживания коммуникации между автором кода и его пользователями/читателями. Например:
size_t safe_strcpy(
    [[gnu::nonnull]] char* dest,
    [[gnu::nonnull]] const char* src,
    size_t dest_size
);
Вы поместили в хэдэр такое объявление, тем самым явно сказав пользователю и компилятору, что указатели не должны быть нулевыми. Если компилятор докажет в compile-time, что в функцию передали nullptr, то он выкинет предупреждение. Ну а пользователь четко по сигнатуре видит, что функция не ожидает нулевой указатель и как порядочный гражданин не будет его передавать. Annotate your code. Stay cool. #cppcore
09 dic 2025, 05:00

🧑🏻‍💻Асинхронность в C++ всегда была испытанием на зрелость. Потоки, мьютексы, коллбеки — и тысячи строк кода, чтобы просто
🧑🏻‍💻Асинхронность в C++ всегда была испытанием на зрелость. Потоки, мьютексы, коллбеки — и тысячи строк кода, чтобы просто дождаться результата. Но в C++20 всё изменилось: корутины убирают боль ручного управления потоками. На открытом уроке разберём, как работает новая модель асинхронности в C++: без громоздких конструкций и перегрузок по CPU. Вы поймёте, как устроены корутины, где их применять и почему они стали стандартом в C++20 и C++23. На практике создадим корутины-генераторы и обсудим их преимущества перед классическими потоками. Если вы уже чувствуете, что ваш C++ проект тонет в callback hell или не масштабируется под нагрузкой — этот вебинар поможет понять, как писать современный, чистый и асинхронный код. 🔥11 декабря в 20:00 МСК. Открытый урок проходит в преддверии старта курса «C++ Developer. Professional». Присоединяйтесь и узнайте, как сделать асинхронность естественной частью вашего кода: https://otus.pw/y4Kh/ Реклама. ООО «Отус онлайн-образование», ОГРН 1177746618576
09 dic 2025, 02:00

​​Атрибуты везде #опытным Используют атрибуты функций не только лишь все, мало кто знает, куда их можно пихать. Есть на самом деле 3 легальных места для навешивания атрибутов на функцию. 1️⃣ Перед типом возвращаемого значения:
[[deprecated]] int foo() { return 42; }
Тогда он работает при непосредственном использовании функции.
foo();
// warning: 'int foo()' is deprecated 
2️⃣ Перед именем функции:
int foo [[deprecated]] () { return 42; }
В таком виде атрибут тоже применяется к самой функции. 3️⃣ После параметров:
int foo() [[gnu::deprecated]] { return 42; }
Тогда атрибут применяется к типу функции, а не к самой функции. Разница вот в чем:
int foo() [[gnu::deprecated]] { return 42; }

int main() {
  foo(); // no warnings
  using FuncType = decltype(foo); // use of type is deprecated
}
Обычный вызов функции прекрасно компилируется. Но вот использование типа функции через decltype помечается как устаревшее. Причем gcc и clang по-разному интерпретируют эту ситуацию. Clang говорит, что gnu::deprecated нельзя применять к типам и игнорирует атрибут. Вот ссылка на годболт для интересующихся. Соответственно, в лямбде в тех же местах можно ставить атрибуты:
auto complicated_compute = [] [[nodiscard]] () [[gnu::deprecated]] {
  return 2 * 2;
};
Признавайтесь, знали?) Have your own opinion. Stay cool. #cppcore
06 dic 2025, 10:00