ru
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 дней
Архив постов
Что нужно знать, чтобы попасть в Яндекс, ОЗОН, СБЕР и другой BigTech? Если ты устал от бесконечных задач на LeetCode, то ты н
Что нужно знать, чтобы попасть в Яндекс, ОЗОН, СБЕР и другой BigTech? Если ты устал от бесконечных задач на LeetCode, то ты не один! Ведь LeetCode не даст четкой системы решения задач, а вот ребята из TSKILLS дадут! Приходи на открытый урок "Хакни массивы", чтобы за 1 час бесплатно ты: - Получишь RoadMap, включающие такие темы как Sliding Window, Префиксные массивы... - Решишь 3+ задачи с собеседований в Яндекс, ОЗОН и Сбер - Научишься оценивать задачи в Big-O нотации - Все примеры на С++, а так же (,java, c++, java script, python) Не упусти шанс, выучить алгоритмы НАВСЕГДА за счет четкой системы решения задач на собесе Регистрируйся на открытый урок (ссылку на трансляцию пришлем в ТГ боте после регистрации) Урок пройдет СЕГОДНЯ - 3 ноября (воскресенье) в 12:30
03 нояб. 2024, 02:00
05 нояб. 2024, ~01:55

Что нужно знать, чтобы попасть в Яндекс, ОЗОН, СБЕР и другой BigTech? Если ты устал от бесконечных задач на LeetCode, то ты н
Что нужно знать, чтобы попасть в Яндекс, ОЗОН, СБЕР и другой BigTech? Если ты устал от бесконечных задач на LeetCode, то ты не один! Ведь LeetCode не даст четкой системы решения задач, а вот ребята из TSKILLS дадут! Приходи на открытый урок "Хакни массивы", чтобы за 1 час бесплатно ты: - Получишь RoadMap, включающие такие темы как Sliding Window, Префиксные массивы... - Решишь 3+ задачи с собеседований в Яндекс, ОЗОН и Сбер - Научишься оценивать задачи в Big-O нотации - Все примеры на С++, а так же (,java, c++, java script, python) Не упусти шанс, выучить алгоритмы НАВСЕГДА за счет четкой системы решения задач на собесе Регистрируйся на открытый урок (ссылку на трансляцию пришлем в ТГ боте после регистрации) Урок пройдет СЕГОДНЯ - 3 ноября (воскресенье) в 12:30
02 нояб. 2024, 03:00
02 нояб. 2024, ~03:00

​​Что происходит до main? Рассмотрим простую программу:
#include <iostream>
#include <random>

int a;
int b;

int main() {
  a = rand();
  b = rand();
  std::cout << (a + b);
}
Все очень просто. Объявляем две глобальные переменные, в main() присваиваем им значения и выводим их сумму на экран. Скомпилировав эту программу, мы сможем посмотреть ее ассемблер и увидеть просто набор меток, соответствующих разным сущностям кода(переменным a и b, функции main). Но вы не увидите какого-то "скрипта". Типа как в питоне. Если питонячий код не оборачивать в функции, то мы точно будем знать, что выполнение будет идти сверху вниз. Так вот, такой простыни ассемблера вы не увидите. Код будет организован так, как будто бы им кто-то будет пользоваться. И это действительно так! Убирая сложные детали, можем увидеть вот такое:
a:
  .zero 4

b:
  .zero 4

main:

  push rbp
  mov rbp, rsp
  call rand
  ...
  call std::basic_ostream<char, std::char_traits<char> >::operator<<(int)
  mov eax, 0
  pop rbp
  ret
Суть программы состоит из меток. Метки нужны, чтобы обращаться к сущностям программы. Да, они и внутри основного кода используются. Но то, что на главной функции стоит метка, говорит нам о том, что ее кто-то вызывает! Но даже до того, как начнет работу сущность, которая вызывает main, нужно проделать большую работу по подготовке программы к исполнению. Давайте просто перечислю, что должно быть сделано: 💥 Программа загружается в оперативную память. 💥 Аллокация памяти для стека. Для исполнения функций и хранения локальных переменных обязательно нужен стек. 💥 Аллокация памяти для кучи. Для программы нужна дополнительная память, которую она берет из кучи. 💥 Инициализация регистров. Там их большое множество. Например, нужно установить текущий указатель на вершину стека(stack pointer), указатель на инструкции(instruction pointer) и тд. 💥 Замапить виртуальное адресное пространство процесса. Процессы не работают с железной памятью напрямую. Они делают это через абстракцию, называемую виртуальная память. 💥 Положить на стек аргументы argc, argv(мб envp). Это аргументы для функции main. 💥 Загрузка динамических библиотек. Программа всегда линкуется с разными динамическими либами, даже если вы этого явно не делаете) 💥 Вызов всякий преинициализирующих функций. Важная оговорка, что это все суперсильное упрощение. В реале все намного сложнее. Не претендую на полноту изложения и правильность порядка шагов. К тому же я говорю только про эквайромент полноценных ОС типа окон и пингвина. В эмбеде могут быть сильные отличия. Обязательно оставляйте свои дополнения процесса старта программы в комментариях. В этих полноценных осях всю эту грязную работу на себя берет загрузчик программ. После того, как эти шаги выполнены, загрузчик может вызывать ту самую функцию _start(название условное, зависит от реализации). Она уже выполняет более прикладные чтоли вещи: 👉🏿 Статическая инициализация глобальных переменных. Это и недавно обсуждаемая zero-инициализация и константная инициализация(когда объект инициализирован константным выражением). То есть инициализируется все, что можно было узнать на этапе компиляции. 👉🏿 Динамическая инициализация глобальных объектов. Выполняется код конструкторов глобальных объектов. 👉🏿 Инициализация стандартного ввода-вывода. Об этом мы говорили тут. 👉🏿 Инициализация еще бог знает чего. Начальное состояние рандомайзера, malloc'а и прочего. Так-то это часть первых шагов, но привожу отдельно, чтобы вы не думали, что только ваши глобальные переменные инициализируются. И только вот после этого всего, когда состояние программы приведено в соответствие с ожиданиями стандарта С++, функция _start вызывает main. Так что, чтобы вы смогли выполнить свою программу, кому-то нужно очень мощно поднапрячься... See what's underneath. Stay cool. #OS #compiler
01 нояб. 2024, 11:00

Уже зимой этого года Google, Gmail, Figma и многие другие сервисы могут стать недоступны! К новым санкциям США многие окажутс
Уже зимой этого года Google, Gmail, Figma и многие другие сервисы могут стать недоступны! К новым санкциям США многие окажутся не готовы и рискуют потерять важные данные и связь с миром, но только не те, кто подписан на Telegram канал IT ВЕДОМСТВО Если вы хотите: -> Первыми получать самые актуальные и важные новости из мира технологий... -> Иметь под рукой готовые инструкции по жизни в техно мире, включая полный список рабочих аналогов популярных программ... -> Знать, как защитить от мошенников в сети свои данные и деньги... ... то не теряйте времени, подписывайтесь на Telegram канал IT ВЕДОМСТВО и будьте готовы к любым изменениям!
01 нояб. 2024, 10:00
04 нояб. 2024, ~09:17

Ответ Самый главный результат опроса - почти треть канала состоит из красивых людей. In mom's humble opinion. И это прекрасно! И настоящие профессионалы, и внешне обаятельны, и в душе поэты! Но ладно, это была лирика(поэт из меня так себе). Перейдем к правильному ответу. Он был замаскирован, видимо поэтому набрал меньше всего голосов. Стандарт говорит:
Because the explicit template argument list follows the function template name, 
and because constructor templates are named without using a function name, 
there is no way to provide an explicit template argument list for these function templates.
Невозможно явно указать шаблонные аргументы для шаблонного конструктора. Компилятор должен суметь вывести эти типы на основе переданных в конструктор аргументов. Но так как в нашем случае конструктор не принимает никаких параметров - компилятор никак не сможет вывести типы. Поэтому невозможно вызвать конструктор у такого класса:
struct Type {
    template <typename>
    Type() {}
};
Но! Объект такого класса создать можно. Некоторые функции в С++ неявно создают объекты. Например std::bit_cast.
struct Type {
  template <typename>
  Type() {};
};

struct Other {};

int main() {
  Type t = std::bit_cast<Type>(Other{});
}
Спасибо @cppnyasha за пример. Но конкретно в нашем случае была задача вызвать конструктор, а это невозможно. Solve problems. Stay cool. #cppcore #cpp20
31 окт. 2024, 05:00

Как правильно вызвать конструктор у такого класса?
Anonymous voting
30 окт. 2024, 06:00

Квиз Вчера в комментах наш подписчик @d7d1cd задал очень интересную задачку, которой мне захотелось с вами поделиться. Да, кто-то уже ее обсудил, но тем, кто не участвовал в дискуссии, тоже будет интересно проверить свои знания в #quiz. Как всегда это бывает с плюсами, задачка не простая и сходу вгоняет в ступор. Но без паники! Вдох, выдох и мы опять играем в любимых, успокоили разум, подумали и ответили. Подписчику спасибо за контент, а у меня для вас всего один вопрос. Как правильно вызвать конструктор у такого класса?
struct Type {
    template <typename>
    Type() {}
};
Challenge your knowledge. Stay cool.
30 окт. 2024, 06:00

14 ноября, YADRO С++ meetup, Москва и онлайн Встречаемся очно или на трансляции — регистрируйтесь, чтобы забронировать место
14 ноября, YADRO С++ meetup, Москва и онлайн Встречаемся очно или на трансляции — регистрируйтесь, чтобы забронировать место и получить ссылку на стрим на одной из популярных платформ.  В программе: • Как сочетать объектный подход с современным программированием. • Паттерны ООП, которые сделают проект гибким и легким в поддержке. • Удобство интрузивных контейнеров. • Что помогает нам в разработке 5G сетей. • Инструменты библиотеки Boost.Intrusive. • Дискуссия: эксперты из YADRO, Яндекса, Syntacore и Касперского обсудят, как протекает реализация стандартов: на сколько быстро внедряются фичи, стоит ли обратить внимание на подходы других языков и становится ли продукт безопасней, если написан на новых стандартах? Офлайн-участники смогут увидеть «железо» для ЦОД и телеком-операторов, код для которого пишут С++ разработчики YADRO, пообщаться с экспертами на мини-стендах, поучаствовать в технических интерактивах и получить призы после митапа. Участие бесплатное, регистрация обязательна. До встречи!
30 окт. 2024, 03:00
02 нояб. 2024, ~06:16

А за сколько вы выучили С++?
А за сколько вы выучили С++?
29 окт. 2024, 05:00

​​Линкуем массивы к объектам Опытные читатели могли заметить кое-что странное в этом посте. И заметили кстати. Изначально cin, cout и тд определены, как простые массивы. А в iostream они уже становятся объектами потоков и линкуются как онные. То есть в одной единице трансляции
extern std::ostream cout;
extern std::istream cin;
...
А в другой
 // Standard stream objects.
  // NB: Iff <iostream> is included, these definitions become wonky.
  typedef char fake_istream[sizeof(istream)]
  attribute ((aligned(alignof(istream))));
  typedef char fake_ostream[sizeof(ostream)]
  attribute ((aligned(alignof(ostream))));
  fake_istream cin;
  fake_ostream cout;
  fake_ostream cerr;
  fake_ostream clog;
Что за приколы такие? Почему массивы нормально линкуются на объекты кастомных классов? В С++ кстати запрещены такие фокусы. Типы объявления и определения сущности должны совпадать. Все потому что линкер особо не заботится о типах, выравнивании и даже особо о размерах объектов. То есть я буквально могу прилинковать объект одного кастомного класса к другому и мне никто никакого предупреждения не влепит. Такой код вполне нормально компилится и запускается:
// header.hpp
#pragma once

struct TwoFields {
  int a;
  int b;
};

struct ThreeFields {
  char a;
  int b;
  long long c;
};

// source.cpp

ThreeFields test = {1, 2, 3};

// main.cpp

#include <iostream>
#include "header.hpp"

extern TwoFields test;

int main() {
  std::cout << test.a << " " << test.b << std::endl;
}
На консоли появится "1 2". Но ни типы, ни размеры типов, ни выравнивания у объектов из объявления и определения не совпадают. Поэтому здесь явное UB. Но в исходниках GCC так удачно сложилось, что массивы реально представляют собой идеальные сосуды для объектов io-потоков. На них даже сконструировали реальные объекты. Поэтому такие массивы можно интерпретировать как сами объекты. Это, естественно, все непереносимо. Но поговорка "спички детям - не игрушка" подходит только для тех, кто плохо понимает, что делает. А разработчики компилятора явно не из этих ребят. Take conscious risks. Stay cool. #cppcore #compiler
28 окт. 2024, 04:10

Я айтишник и я устал! С годами работы в IT все сильнее напрягает рутина, прокрастинация, куча задач и 0 желания их выполнять.
Я айтишник и я устал! С годами работы в IT все сильнее напрягает рутина, прокрастинация, куча задач и 0 желания их выполнять. Че делать? Хватит грызть самого себя и заставлять через силу - сделаешь только хуже! Лучше подпишись на того, кто уже не первый год работает с IT-специалистами и помогает им справиться с апатией и прокрастинацией - Психолог с научным подходом. ✔️ Как оторваться от ленты соцсетей и сесть за работу с удовольствием? ✔️ Как спокойно общаться с коллегами, если они бесят? ✔️ Как избавиться от постоянной тревожности? ✔️ Как успокоить конфликты в семье и перестать срываться на всех, а вместо этого получить поддержку и понимание со стороны близких? Подписывайся на канал @remizov_changes - начни работать и жить в кайф, не скатываясь в кризисы и выгорание! А в закрепе тебя уже ждут бонусы: 👨🏻‍💻 Видео, в котором ты найдёшь ответ на вопрос «Почему у тебя нет энергии и что с этим делать» + гайд как it-специалисту вернуть энергию, даже если не получается отдохнуть. https://t.me/+srQ8N42LB-42ODFi
28 окт. 2024, 02:10
30 окт. 2024, ~06:57

​​std::cout Кажется, что на начальном этапе становления про-с++-ером, вывод в использование конструкции:
std::cout << "Print something in consol\n";
воспринимается, как "штука, которая выводит текст на консоль". Даже со временем картинка не до конца складывается и на вопрос "что такое std::cout?", многие плывут. Сегодня закроем этот вопрос. В этой строчке мы вызываем такой оператор:
std::ostream& operator<< (std::ostream& stream, const char * str)
Получается, что std::cout - объект класса std::ostream. И ни какой-то там временный. Раз он принимается по левой ссылке, значит он уже где-то хранится в памяти. Но мы же ничего не делаем для его создания? Откуда он взялся? Мы говорили о том, что есть "невидимые" для нас вещи, которые происходят при старте программы. Так вот, это одна из таких вещей. std::cout - глобальный объект типа std::ostream. За его создание отвечает класс std::ios_base::Init, инстанс которого явно или неявно определяется в библиотеке <iostream>. Но это все слова. И новичкам будет достаточно этого. Но мы тут глубоко закапываемся, поэтому давайте закопаемся в код. Полазаем по исходникам gcc. Ссылочки кликабельные для пытливых умов. А в хэдэре iostream мы можем найти вот это:
extern istream cin;  ///< Linked to standard input
extern ostream cout;  ///< Linked to standard output
extern ostream cerr;  ///< Linked to standard error (unbuffered)
extern ostream clog;  ///< Linked to standard error (buffered)
...
static ios_base::Init __ioinit;
Здесь определяются символы стандартных потоков и создается глобальная переменная класса ios_base::Init. Пойдемте тогда в конструктор:
ios_base::Init::Init()
  {
    if (__gnu_cxx::__exchange_and_add_dispatch(&_S_refcount, 1) == 0)
      {
    // Standard streams default to synced with "C" operations.
    _S_synced_with_stdio = true;

    new (&buf_cout_sync) stdio_sync_filebuf<char>(stdout);
    new (&buf_cin_sync) stdio_sync_filebuf<char>(stdin);
    new (&buf_cerr_sync) stdio_sync_filebuf<char>(stderr);

    // The standard streams are constructed once only and never
    // destroyed.
    new (&cout) ostream(&buf_cout_sync);
    new (&cin) istream(&buf_cin_sync);
    new (&cerr) ostream(&buf_cerr_sync);
    new (&clog) ostream(&buf_cerr_sync);
    cin.tie(&cout);
    cerr.setf(ios_base::unitbuf);
    // _GLIBCXX_RESOLVE_LIB_DEFECTS
    // 455. cerr::tie() and wcerr::tie() are overspecified.
    cerr.tie(&cout);
    ...
    __gnu_cxx::__atomic_add_dispatch(&_S_refcount, 1);
Немножко разберем происходящее. В условии проверяется ref_count, чтобы предотвратить повторную инициализацию. Так как не предполагается, что такие объекты, как cout будут удалены, они просто создаются через placement new с помощью инстансов stdio_sync_filebuf<char>. Это внутренний буфер для объектов потоков, который ассоциирован с "файлами" stdout, stdin, stderr. Буферы как раз и предназначены для получения/записи io данных. Хорошо. Мы видим как и где создаются объекты. Но это же placement new. Для объектов уже должная быть подготовлена память для их размещения. Где же она? В файлике globals_io.cc:
 // Standard stream objects.
  // NB: Iff <iostream> is included, these definitions become wonky.
  typedef char fake_istream[sizeof(istream)]
  attribute ((aligned(alignof(istream))));
  typedef char fake_ostream[sizeof(ostream)]
  attribute ((aligned(alignof(ostream))));
  fake_istream cin;
  fake_ostream cout;
  fake_ostream cerr;
  fake_ostream clog;
то есть, объекты - это пустые символьные массивы правильного размера и выравнивания. Все это должно вам дать довольно полное представление, что такое стандартные потоки ввода-вывода. #cppcore #compiler
27 окт. 2024, 11:00

Сотрудники Авито ведут свой telegram-канал ⭐️ И знаете, получилось мега-лампово и увлекательно. Всего через несколько постов
Сотрудники Авито ведут свой telegram-канал ⭐️ И знаете, получилось мега-лампово и увлекательно. Всего через несколько постов начинаешь уже чувствовать себя частью их уютного офиса: рядом — знакомые весёлые коллеги из постов, и вам точно есть что обсудить. А вообще хвалим и одобряем. Во-первых, смело и интересно. Во-вторых, для тех, кто рассматривает работу в Авито, это возможность изучить культуру и вайб компании ещё до трудоустройства. 🔥 Однозначно подписка — @avito_life 🔥🔥 Если думаешь о работе в Авито, то добавляй сразу — @avito_career
27 окт. 2024, 10:00
28 окт. 2024, ~10:10

​​Программа без main? Все мы знаем, что функция main - входная точка в программу. С нее начинается исполнение программы, если не считать глобальные переменные. Без функции main программа просто не запустится. Или нет? Может быть мы можем что-нибудь нахимичить, чтобы, например, написать Hello, World без main? Оказывается, можем. Однако, естественно, это все непереносимо. Но она на то и магия, что у разных магов свои заклинания. Скомпилируем вот такую программу под gcc с флагом -nostartfiles:
#include <iostream>

int my_fun();

void _start()
{
  int x = my_fun();
  exit(x);
}

int my_fun() 
{
  std::cout << "Hello, World!\n";
  
  return 0;
}
И на консоли появится наша горячо-любимая надпись: Hello, World! Для любителей поиграться с кодом вот вам ссылочка на годболт. А вот что за такая функция _start и какой все-таки код выполняется до main, мы поговорим в следующий раз. Make impossible things. Stay cool. #fun #cppcore
26 окт. 2024, 06:06

​​Почему тогда локальные переменные не зануляются? Вчера мы разобрали, что когда операционка выдает процессу память, она ее зануляет. Тогда получается, что сегмент глобальных данных автоматически заполнен нулями. Но возникает вопрос: раз ОС такая молодец и зануляет всю память, то почему локальные переменные и куча заполнены мусором? Какие-то двойные стандарты. Все на самом деле немножко сложнее. Есть такое понятие, как "zero-fill on demand". Заполнение нулями по требованию. Когда процесс запрашивает память под свои сегменты, стек и кучу, ОС на самом деле не дает ему реальные страницы памяти. А дает "виртуальные". То есть ничего не аллоцирует по факту. Такие страницы заполнены нулями. Процесс может свободно читать эти страницы и будет действительно видеть там нули. Однако это не будет физической памятью. Как только процесс захочет что-то записать в нее, только тогда операционка разрождается, реально аллоцирует физическую страницу и копирует в нее содержимое той виртуальной страницы. То есть заполняет физическую нулями. И так она делает один раз на каждую физическую страницу. Вот как появляются нули в реальной памяти. Теперь почему они не остаются навсегда. Дело в том, что процесс переиспользует свою память. Программа в течение всей своей жизни использует один и тот же стек и кучу. Мы выделили маллоком массив байт, попользовали его и освободили. И эта память не вернулась операционке. Процесс может ее переиспользовать. Да, изначально, при попытке записи в эти байты, ОС выдавала зануленные страницы. Но после того, как мы ими попользовались, там уже лежат наши данные. И с точки зрения куска программы, которая в следующий раз получит эту память, там уже лежит "мусор". Но это просто данные из предыдущей аллокации. Также и локальные переменные. Мы выполнили одну функцию, вернулись обратно, и выполняя следующую функцию, мы будем переиспользовать память стека под локальные переменные. Именно поэтому кстати, мы можем очень легко получить доступ к данным, которые лежали на стеке ранее:
void fun1() {
  int initialize = 10;
  std::cout << initialize << std::endl;
}

void fun2() {
  int uninitialize;
  std::cout << uninitialize << std::endl;
}

int main() {
  fun2();
  fun1();
  fun2();
}
Возможный вывод такого кода:
32760
10
10
Обратите внимание, что, вызывая функцию с переменной uninitialize в первый раз, мы получили мусор. Однако после вызова func1, где переменная инициализирована, в памяти стека на месте, где лежала initialize будет лежать число 10. Так как сигнатуры и содержимое функций в целом идентичны, то uninitialize во второй раз будет располагаться на том же самом месте, где и была переменная initialize. Соответственно, она будет содержать то же значение. А учитывая, что до пользовательского кода выполняется некий "скрытый код", то даже в "начале" программы вы будете видеть на стеке мусор. Reuse resources. Stay cool. #OS #compiler
24 окт. 2024, 13:12

👩‍💻 Программирование теперь в Telegram! Вот 10 обучающих каналов по самым востребованным направлениям в IT. Выбирай своё на
👩‍💻 Программирование теперь в Telegram! Вот 10 обучающих каналов по самым востребованным направлениям в IT. Выбирай своё направление: 👩‍💻 C/C++: @cpp_ready 👩‍💻 C#: @csharp_ready 👩‍💻 Python: @python_ready 👩‍💻 Java: @java_ready 👩‍💻 Frontend: @code_ready 👩‍💻 Backend: @backend_ready 🖥 Базы Данных & SQL: @sql_ready 👩‍💻 Все языки: @roadmap_ready 📖 IT Архив: @archive_ready 🖥 Design: @time_design 📌 Ресурсы, гайды, шпаргалки, книги и задачи для каждого языка программирования.
24 окт. 2024, 10:12
28 окт. 2024, ~16:53

​​Бесплатная zero-инициализация Вчера я сказал, что иногда в самой программе может попросту отсутствовать код по занулению неинициализированных глобальных переменных. Сегодня разберем, за счет чего это может достигаться. Во время старта программы ей необходимо выделить память под такие вещи, как стек, кучу, код самой программы и глобальные переменные. Память программе предоставляет операционная система. Ну и естественно, что в эту память раньше была записана какая-то информация. Вообще говоря, потенциально конфиденциальная. То есть раньше был какой-то процесс, который писал информацию в память, завершился, и теперь ее отдают другому процессу. И что получается, наш новорожденный процесс может видеть какую-то конфиденциальную информацию? Это же большая уязвимость. Может ли операционная система опираться на честность человека, написавшего код, или на компилятор, что кто-то из них останется приличным парнем и сам занулит всю выданную программе память? В большинстве случаев может. Но здесь очень важны исключения, которых быть не должно. Поэтому ОС никому не доверяет и сама зануляет всю память, которую выдает новому процессу. Компилятор/линкер при формировании бинарника собирает все неинициализированные переменные вместе в одну секцию с названием .bss. Получается, при старте программы у ОС запрашивается память в том числе под секцию .bss, и эта память уже аллоцируется зануленной! И никакого кода не нужно, за нас все делает операционка. Важное уточнение, что такое поведение наблюдается не у всех операционок. Да, все эти ваши винды, линуксы и прочие макоси зануляют память перед ее передачей другому процессу. Но для каких-нибудь микроконтроллеров это может быть неактуально и компилятор должен честно вставить код зануления для того, чтобы соблюсти требования стандарта. В чате последние пару дней были бурные обсуждения того, что этого зануления может и не быть. Ну как бы, может и не быть. Только тогда компилятор будет противоречить стандарту. И пользоваться им можно на свой страх и риск. Don't reveal secrets. Stay cool. #OS #compiler #cppcore
23 окт. 2024, 05:00

​​Разница инициализаций После вчерашнего поста у некоторых читателей мог возникнуть резонный вопрос. Почему глобальные переменные инициализируются автоматически, а локальные - нет? Не легче ли было установить какое-то одно правило для всех? Единые правила - хорошая вещь. И как многие хорошие вещи, они чего-то стоят. А в С++ есть такой девиз: "мы не платим за то, что не используем". Мне не всегда нужно задавать значение переменной. Иногда меня это вообще не интересует. Я могу создать неинициализированную переменную и передать ее в функцию, где ей присвоится конкретное значение.
int i;
FillUpVariable(i);
Чтобы ответить на вопрос из начала поста, давайте посмотрим, чем мы вообще платим за инициализацию в обоих случаях. Рассмотрим локальные переменные. В сущности, они являются просто набором байт на текущем фрейме стека. И программа интерпретирует эти байты, как наши локальные переменные. Чтобы инициализировать локальную переменную, нужно положить нолик в каждый байтик, который ассоциирован с этой переменной. И так нужно делать каждый раз при каждом вызове функции. Итого стоимость инициализации: немножко кода на зануление памяти при каждом входе в скоуп переменной. Теперь глобальные переменные Они инициализируются всего один раз при старте программы. Соответственно, стоимость - немножко кода 1 раз при старте программы. Причем обычно, когда мы говорим про какие-то затраты и перфоманс, мы говорим о времени, когда программа уже делает полезную работу. То есть инициализация глобальных переменных проходит в "бесплатное" с точки зрения производительности время. Итого мы получаем, что предварительная установка значений глобальных переменных проходит для нас фактически бесплатно, а для локальных переменных мы тратимся на каждый вход в скоуп переменной. Теперь представьте, что мы бы потребовали устанавливать валидное значение всегда. Это просто неэффективно. Да и не нужно. Кстати, на самом деле zero-инициализация глобальных переменных может обходится нам действительно бесплатно. И никаких кавычек! Но об этом в следующем посте. Be effective. Stay cool. #cppcore #compiler
22 окт. 2024, 05:00

Ответ Для начала - код полностью валидный и успешно соберется. Нехватка ретурна никак не мешает.
If control reaches the end of main without encountering a return statement, the effect is that of executing return 0
Дальше. Весь прикол тут в том, что id - глобальная переменная. Действительно, если бы она была локальной переменной main:
int main()  
{  
  int id;
  std::cout << id; 
}
то было бы использование неинициализированной переменной, неопределенное поведение и на экран вывелся бы мусор. Однако id - глобальная переменная. К ним применяются немного другие правила. Дело в том, что все глобальные переменные инициализируются перед main. Вопрос только в том, как они это делают. В данном случае, так как нет явного инициализатора, происходит так называемая zero-инициализация. И id будет равно 0. Итого. На экране появится "0". Stay defined. Stay cool. #cppcore
21 окт. 2024, 12:00

Результат попытки компиляции и запуска?
Anonymous voting
21 окт. 2024, 08:00