Оптимизация математики в GCC

Помните, как в школе нас просили упростить математические выражения? Что-то типа корень из x * x = x. Так вот, компиляторы умеют также. Только по умолчанию им это делать запрещено 🤷

Так и зачем? Были бы программки быстрее, VPN работал шустрее (но это не точно) 😅. Допустим есть следующая функция:

#include <cmath>

float root_of_square(float value) {
return std::sqrt(value * value);
}

Эта функция возводит число в квадрат и потом извлекает корень. Ну прям как в школьном примере выше 🤓.

Иногда такое (бессмысленное) встречается, особенно в исследовательском коде 🧐. Зачем — не спрашивайте, я даже не знаю. Самое интересно, что если скоратить эту функцию, как мы делали в школе — то решение будет работать уже не совсем точно. Это связано с тем, что часто исследователи закладываются на вычислительные ошибки, связаные с представлением чисел с плавающей точкой (то, что обычно мы называем десятичная дробь).

Так вот, в копиляторе GCC существует флаг -ffast-math, который включает целый класс оптимизаций математических операций во время сборки приложения. Про этот флаг обычно говорят: если не знаешь, лучше не трогай. И это действительно так, если его применить, то даже без вмешательства нашей школьной оптимизации, компилятор сам поймет, что тут можно оптимизировать и сделает это. А потом вы будете искать баги днями и ночами, потому что такое найти — ну оооочень сложно🤪.

Грамотная оптимизация всегда позволяет сделать приложение быстрее. Например, если вы воспользуетесь флагом -fassociative-math, который входит в состав -ffast-math, то это позволит задействовать ассоциативные правила из математики. Это также повлияет на циклы, ведь возможна ситуация, когда вычисления можно векторизовать (выполнить одновременно).

Напоследок порекомендую интересную статью про то, как влияют различные флаги оптимизации математики. Ну и конечно, читайте документацию, всегда полезно.

#разработка

Abseil

👨‍💻Сегодня мне хочется написать об очень крутом сборнике библиотек для С++ — Abseil. Чтобы не быть голословным, я просто оставлю здесь то, что написано у них на сайте о себе:

Abseil encompasses the most basic building blocks of Google’s codebase: code that is production-tested and will be fully maintained for years to come.

С чего всё началось?
Как я понял, ребятки в Google очень любят писать хороший, быстрый, чистый (и всякие другие эпитеты) код 🤫. В куче своих проектов, они использовали одни и те же сущности, который можно было бы выделить в отдельное место. Общие части однажды вынесли и появился Abseil. 👶

Ну например, в С++11 не было метода std::make_unique. В библиотеке memory, которая находится в составе Abseil, он реализован. Или, например, понадобился вам std::variant в С++11 — пожалуйста, берите из библиотеки types.

Почему Abseil, а не что-то другое 🤔?
Каждую сущность выше можно было бы реализовать самим, найти отдельные имплементации. Есть несколько но:
1. Код Abseil протестирован — это очень важно, когда вы пишите код для реальных систем;
2. Код Abseil зарекомендовал себя временем и именитыми пользователями — не буду возвышать здесь Google, но раз они у себя его используют, это повод задуматься (они же могут 100500 раз написать подобное сами);
3. Apache 2 лицензия — можно использовать как в open-source, так и в коммерческих проектах бесплатно💸!

Почему я вообще о ней заговорил?
Эта библиотека мне уже парочку раз спасла жизнь ☺️. Особенно когда мы написали очень много кода на С++17, а тут по стечению обстоятельств оказалось, что нужно использовать С++11 🤷. С точностью до некоторых моментов, Abseil позволяет это сделать очень просто. А если вы использовали этот сборник с самого начала проекта — переход между стандартами языка осуществляется простой сменой флага в системе сборки.

Также мне приятно читать их код. Не знаю, почему так происходит, но для меня он опрятен и вызывает мурашки. При должном внимании, можно понять, что происходит — не всегда такое возможно.

В общем-то, если когда-то будете писать на С++, подумайте, возможно использование Abseil может помочь вам решить незакрытые вопросики.

#разработка

AddressSanitizer

В С++ компиляторах (по крайней мере, в gcc/clang), есть такая штука, как AddressSanitizer. Она помогает находить ошибки адрессации в коде. Объясню на простеньком примере 👶.

Представьте, вы приехали домой. Вам сварили борщик, вкусный такой, нажористый, домашний 🍛. Подали кусочек ржаного хлебшука, натертого с чесночком, да и сальце тоже не забыли 🍞. Будем считать это аналогией инициализации ресурсов в программе.

Вы кушаете борщик, вспоминаете детство, закусываете кусочком хлеба. OMG, думаете вы, как вкусно 😍. Но борщик постепенно заканчивается, но вам всё равно. Вы не замечаете, как съедаете борщик 😅. Всё, мы тут воспользовались ресурсами и уничтожили их в программе.

А теперь самое интересное: вы тянетесь ложкой в тарелочку с борщиком, всё в мыслях, кладете эту ложку в рот и тут уже понимаете, что ложка-то пустая, борщ съеден уже был 🤨. Вот тут мы в разработке сталкиваемся с обращением к ресурсу, который уже уничтожили.

В реальности, никаких проблем нет. Ну пустая ложка и пустая (хотя обидно всё же). А в приложении обычно ложек пустых не бывает (допустим, тарелка заполнилась землей автоматически), а значит мы "скушаем" чего-то не то, от этого будут проблемы 🤯.

И в лучшем случае, хорошо, если мы обращаемся к ресурсу на чтение. А если запись? А если ресурсы системные? В общем — это больно, тяжело ловить при отладке 😢.

Вообще в компиляторах есть несколько инструментов типа *Sanitizer:
ThreadSanitizer — помогает находить ошибки в многопоточном приложении, когда два или более потоков пытаются менять одну и ту же область памяти;
LeakSanitizer — обычно включается вместе с AddressSanitizer и нужен для поиска утечек памяти;
UndefinedBehaviorSanitizer — инструмент для поиска undefined behavior аномалий.

В своих проектах я предпочитаю использовать все инструменты, если это необходимо и если это возможно 🤗. Это помогает отлавливать совсем неочевидные ошибки и много раз спасало от возможных проблем 🥲. Хотя, конечно, это не панацея — у него есть и свои баги, свои ложные срабатывания/не срабатывания.

Также AddressSanitizer выделяется на фоне всех остальных похожих инструментов своим быстродействием ⚡️. Разработчики запарились и придумали просто гениальную стратегию отслеживания работы с памятью. Советую ознакомиться с принципом работы инструмента.

И еще пару слов про то, почему не всегда возможно использовать инструмент. Некоторые сторонние зависимости имеют баги🥷, если их очень много, даже если ваше приложение написано идеально, санитайзер будет ругаться 😡. И тут нужно быть просто осторожным и искать проблему там, где она есть, а не где думается.

Напоследок два доклада про санитайзер на русском: тык, тык. На английском: тык. Презентация с одного из докладов: тык.

#разработка

CalDigit TS4

Я тот еще фанат техники🥷. Совсем недавно я стал задумываться, как бы обустроить своё рабочее место.

Я думаю над тем, чтобы купить ортопедическое кресло Herman Miller (правда, сейчас оно стоит просто нереальных денег) и стол с механизмом автоподъема, например от этих ребят.💸 Но это всё базовые вещи (в плане стол + кресло), без которых комфортабельное рабочее место невозможно.

Те, кто организовывал (или пытался) своё рабочее пространство, знают, что одна из больших болей — это провода😢. Их может быть 100500, а хочется получить немного эстетического удовольствия от рабочего места.☺️

Большинство проводки можно спрятать под стол.😉 Но очень много девайсов нужно подключать к макбуку — у которого в лучшем случае портов 4, в среднем — два. В моем случае это целый набор: внешний SSD, монитор, мышка, зарядка, иногда зарядка для часов, иногда еще что-то🤯. В итоге мой макбук стоит как чудище с руками-проводами🧟. А еще это очень некомфортно каждый раз отсоединять/присоединять, когда нужно взять ноутбук с собой.😓

Я стал гуглить, как вообще люди обходятся в таком случае, кейс же частый. Оказывается, все уже придумали. Я бы назвал эту концепцию — магия одного провода.💫

Суть в том, что вы соединяете макбук (или ваш ноутбук) с док станцией по кабелю. Пока ничего нового. Но давайте взглянем на вот эту штучку — CalDigit TS4.

Серьезно? 18 портов? Одновременная зарядка с передачей данных? 2.5 Гбит порт интернета? 10 Гб/с передача данных по USB-C? Подключение к монитору? И это всё по одному кабелю? Что за магия?🤷

Оказывается, всё очень просто. Ребятки из Intel вместе с Apple разработали стандарт Thunderbolt. И уже давно как макбуки и продвинутые ноуты содержат разъёмы с этой технологией. 🤨

Если честно, я всегда думал, что это какая-то маркетинговая фишка Apple, мол не USB-C, а Thunderbolt (они же так любят делать). Оказывается это очень мощная штука. За счет конструктивных особенностей данный разъем позволяет поддерживать огромное число устройств, а также передавать данные с бешенной скоростью. 🤓

Но Thunderbolt — это не только разъем, но и провод. И тут вообще всё очень сложно. Чтобы поддерживать заявленную пропускную способность, медный вариант кабеля пока может достигать только 3м в длину. Где-то пишут, что есть оптоволоконные Thunderbolt кабели и они могут достагать 30м в длину.🙈

И что нам даёт знание о длине? Только лишь то, что эти кабели из-за своих конструктивных особенностей стоят бешенных денег. Например, у того же CalDigit кабель Thunderbolt 4 на 2м стоит $75. Неплохо так. 💸

К чему этот текст про Thunderbolt? Когда вы видите кабель от Apple, который стоит в 20 раз дороже китайского, то это не только за бренд. Огромные силы вложены даже в простой переходник, чтобы тот выдавал вам максимум от используемых девайсов. Так что покупайте оригиналы, не путайте провода для своих девайсов.

Немного интересной информации про Thunderbolt вы можете прочитать здесь. Кстати говоря, описывают в чем разница между 3 и 4 стандартами.

А CalDigit TS4 я планирую себе купить. Правда пока не знаю, как это сделать из РФ. Может быть кто-то может помочь, кто сейчас зарубежом?🙏

#разное

Конференция 🤓

Ух! Как давно я не писал! Задались плотные деньки!
Подготовка диплома, новые проекты на работе 🙂

По правилам магистратуры, студент должен написать статью или выступить с докладом на конференции. Тема работы должна каким-то образом соприкасаться с выпускной квалификационной работой. 🤓

Как и бывает в любом стартапе — мы просрочили все дедлайны. И успевали подать только на одну конференцию — FRUCT. В целом забавная тусовка, но рейтинг у неё околонулевой. 😢

Ну делать было нечего — пишем. Это была моя первая собственная статья, которую я написал сам. Так еще и на английском языке. В начале работы я вообще не верил, что смогу — но получилось. Это был сложный месяц февраль. Мне кажется, что я со своим научником сделали какую-то нереальную работу.🥷

Во время выступления на конференции в моей группе были ребята в основном русские, но все говорили на английском. Эдакий "Science English Club". 🤫

Мне было интересно поучаствовать во всём этом. Но также я понял, что написание статей — это не моё. Слишком много формальностей, слишком многим нужно доказать (если у тебя нет авторитета в научном мире). И это даже для околонулевой конференции. Я лучше буду писать код, работать с людьми, делать "промышленное" исследование, а науку оставлю ребятам, которые в ней понимают и которым она доставляет удовольствие. 😇

Ссылочка на мою работу.

Нас обманывали, а мы и не заметили (Часть 1)

На днях я задумался, а можно ли как-то получить доступ к тому, к чему обычно нельзя просто так обратиться. Например, к private полям класса, без его модификации в С++. Оказывается, при большом желании — да. Как это сделать, я расскажу в следующих сериях, а покамест ограничимся только protected полями.

Определим простой класс с полем:

class A {
public:
int Get() const { // Чтобы выводить в консольку
return a;
}
protected:
int a = 10;
};

Шикарно. Теперь используем using declaration, чтобы в наследнике вытащить поле в public секцию примерно так:

class B : public A {
public:
using A::a;
};

Заметим, что если мы сделаем поле у класса A — private, то такой трюк не получится сделать, потому что приватные поля при наследовании всегда остаются приватными.

Как бы теперь превратить A в B. Первое, что приходит в голову — использовать move-семантику (т.е. будем не копировать данные, а именно перемещать). Поэтому превращение можно сделать так:

class B : public A {
public:
using A::a;

B(A&& value) : A(std::forward<A>(value)) {} // паттерн перемещения

A ConvertToA() { // функция для конвертации обратно в A
A a = std::move(*this); // Перемещаем себя же обратно в A
return a; // Возвращаем новый A
}
};

Ух, сложно. Попробуем это всё дело запустить:

A a; // Создаем переменную
std::cout << a.Get() << std::endl; // выведет 10
{
B b(std::move(a));
b.a = 20;
a = b.ConvertToA();
}
std::cout << a.Get() << std::endl; // выведет 20

Как видите, всё работает. Но есть проблемки — перемещение данных и всё такое. Как-то это не серьезно, что ли. Давайте усложним задачу и запретим перемещение:

class A2 {
public:
int Get() const {
return a;
}
A2() = default; // нужно определить конструктор по умолчанию
A2(A2&&) = delete; // удаляем перемещение, т.е. std::move не воспользоваться
protected:
int a = 10;
};

Как же быть? Ну всё просто. Вернемся к первоначальному варианту класса B, только назовем его C:

class C : public A2 {
public:
using A2::a;
};

Заметим, что C не добавляет никаких данных, а поэтому практически всегда его представление в памяти совпадает с A2. Тогда можно попробовать воспользоваться reinterpret_cast:

{
A2 a2;
std::cout << a2.Get() << std::endl; // выведет 10
C& c = reinterpret_cast<C&>(a2);
c.a = 30;
std::cout << a2.Get() << std::endl; // выведет 30
}

И вот это уже магия. Здесь ничего не перемещалось, но при этом мы изменили данные, которые недоступны извне.

Это очень интересный трюк, который показывает силу языка, но я надеюсь, он никогда вам не понадобится. Все же мы сделали очень много допущений. Но это даже неважно. Необходимо понимать, что если скрыли данные — то в этом был смысл. И не нужно пытаться получить к ним доступ, если не дают.

P.S. Можете запустить это в godbolt.

#разработка

Нас обманывали, а мы и не заметили (Часть 2)

Рассказываю, как поменять приватное поле класса. Возьмем класс A из поста выше, заменим protected секцию на private:

class A {
public:
int Get() const { // Чтобы выводить в консольку
return a;
}
private:
int a = 10;
};

Давайте подменим значения поля a с помощью нехитрого кода:

A a;
std::cout << a.Get() << std::endl; // выведет 10
static_cast<int*>(static_cast<void*>(&a))[0] = 20;
std::cout << a.Get() << std::endl; // выведет 20

Что произошло 🤯? Мы представили область памяти, где лежит объект A, в виде массива int — чиселок. Внутри только одно число, а потому обращаясь к нулевому элементу типа int, мы обращаемся к содержимому объекта a и меняем его. Здесь нам повезло — мы знали, что у класса A поле типа int.

Пора раскрывать карты и поговорить немного о том, как объект класса располагается в памяти ПК. Символом # я буду означать 1 байт памяти.

Объект выше показанного класса будет располагаться в пямяти как 4 байта (почти всегда):
####

Почему так? Потому что int на современных ПК занимает 4 байта. В этом классе больше нет никакой информации (поверьте, её бывает очень много). Все вызовы функций определяются еще на этапе компиляции. Именно поэтому, по другому представив объект (в виде массива int) — мы с легкостью заменили переменную в объекте 🥲.

Давайте теперь в классе A заменим int на double, назовем этот класс B. На современных ПК double занимает 8 байт и выглядит так:
########

Запустим тот же код:

B b;
std::cout << b.Get() << std::endl; // выведет 10
static_cast<int*>(static_cast<void*>(&b))[0] = 20;
std::cout << b.Get() << std::endl; // выведет 10

ХАХ! А ничего не работает 😤! Обманул вас Антон! На самом деле нет. Давайте по порядку. Когда мы представляем объект в виде массива чисел, мы говорим компилятору: фрагментируй память по 4 байта (по размеру типа int), поэтому пямять объекта разобъется так:
#### ####

Получается две чиселки типа int. Ну хорошо, мы поменяли первую чиселку, должно же было что-то поменяться. Давайте чтоли попробуем вторую чиселку поменять:

static_cast<int*>(static_cast<void*>(&b))[1] = 20;
std::cout << b.Get() << std::endl; // выведет 4.24399e-313

Тэк-с...🤨 Что-то явно пошло не так. Или так?

На самом деле мы с вами столкнулись с самой большой болью C++ разработчиков — работой с памятью 😩. Программист в этом языке может напрямую менять значения в памяти, но нередко это делается неправильно 🤷. Например, как я намеренно это сделал, предствив число double в виде двух int. Тип double намного сложнее, подробнее про это можно почитать здесь. И просто так там значение не подменить.

Куда бОльшие проблемы появляются, когда путем перезатераний памяти мы теряем место, где выделили какую-то память. Происходит утечка памяти (ваши игры именно так и вылетают) — с одной стороны, место в памяти вроде как не нужно больше, с другой стороны — операционная система не дает заполнить это место, потому что мы там ничего не освободили, а сделать этого не можем, потому что место потеряли 😂.

Все эти private, protected секции в языке — это некоторые гарантии языка на уровне абстракций для классов. Но как только переходим на уровень, где происходит работа с памятью напрямую — никакая гарантия языка не поможет. Насколько я знаю, именно за счет того, что разработчики не позаботились о дополнительном сокрытии переменных, с помощью ArtMoney в играх можно было хакнуть себе ресурсов побольше — программа просто лезла в область памяти вашей программы и находила байты, в которых лежат чиселки, похожие на заданные 🥷.

Все операции выше — сугубо в учебных целях. На практике это пригождается в очень специфических кейсах и надо иметь четкие гарантии и представление, что все будет именно так, как задумывалось. Иначе поменяем int, а нужно было double. Лично я сталкивался с этим один раз в жизни, когда связывал Objective-C и C++ для алгоритмов ray casting.

В следующем посте я расскажу подробнее про то, как классы устроены в памяти. Там не всё так просто!

P.S. Ссылочка на godbolt.

#разработка

Выравние или то, на что обычно забивают 🙈

Как я уже упомянул в прошлом посте: классы — штука непростая. И сейчас я постараюсь описать некоторые интересные чудеса.

Для начала интересно узнать, каков размер пустого класса? Такого как этот:

class A {};

Если вы скажите 0 — вы будете неправы. Или правы? Или нет?😅 С точки зрения теории размер правда должен быть равен 0. Но объекты класса нужно между собой различать, даже если класс пустой. Это значит, что какую-то память да выделить надо. По стандарту минимальный размер объекта — 1 байт. Это вам и выдаст sifeof(A) — команда, по которой можно узнать размер объекта/класса в C++.

Забавно то, что если мы сделаем следующий класс:

class B {
int8_t b;
}

Чиселка в int означает число бит. Например: int8_t — это 8 бит или 1 байт; int32_t — это 32 бита или 4 байта. Подробнее про такие типы здесь.

то его размер тоже будет 1 байт. Просто в случае, когда класс пустой — нам память нужна просто для того, чтобы различать объекты. В случае класса B нам уже нужно хранить данные.😇

Пойдем немного дальше. Объявим следующий класс:

class C {
int32_t a;
int8_t b;
int32_t c;
};

С точки зрения логики здесь 9 байт. Но на самом деле будет 12 байт. Это происходит из-за выравнивания по ширине максимального фундаментального типа. Выравнивание необходимо для более быстрого чтения структуры и доступа с к данным. Но что в реальной практике достаточно часто можно увидеть, так классы пишут по следующему примеру:

class D {
int32_t a;
int8_t b;
int32_t c;
int8_t d;
};

Эта структура будет занимать целых 16 байт, в то время как реальных данных тут на 10 байт 😡. Всё остальное — это выравнивание. Поменяйте c и d местами — получите 12 байт, бесплатно без регистрации и смс 🗿.

Но иногда нам всё же нужно получить максимально сжатую структуру. В C++ это можно сделать с помощью pragma pack:

#pragma pack(push, 1)
class D2 {
int32_t a;
int8_t b;
int32_t c;
int8_t d;
};
#pragma pack(pop)

В этом случае структура D2 будет точно иметь 10 байт 🥷. Но производительность системы может упасть, из-за того, что не всегда поддерживаются быстрые операции со структурурами, у которых убрали выравнивание. Так что баланс соблюден — либо побыстрее, либо поменьше.

Подробнее про объекты можно почитать здесь.

Посмотреть на выводы можно здесь.

#разработка

GIT Анимашки

В жизни каждого из нас возникает период, когда необходимо делиться своими знаниями с новыми коллегами или новичками 👶. На такие случаи я собираю отдельную библиотечку, в которой храню полезные ссылочки 🤫.

Тут я подумал, что может быть и вам тоже будет интересно, поэтому время от времени буду разбавлять свои технические посты такими ресурсами. 😇

Одна из больших болей у начинающих в разработке — это работа с VCS (version control system). Если кратко — это инструмент, который позволяет хранить не только сами файлы, но и историю их изменений. Это очень удобно для текстовых форматов данных — можно понять, кто, когда и зачем добавил ту или иную строчку. Для больших файлов (3D модели, видео, аудио, картинки) существует GIT-LFS. У себя на работе мы используем GIT и сервис для удобного взаимодействия с ним — GitLab.

На днях я наткнулся на интересный пост с очень красивыми анимациями того, как работают основные и полезные команды Git.

Добавляйте себе в закладки!💫

#полезное #управление

Инициализация весов в нейронных сетях

Один из самых очевидных и недооцененных моментов во время подготовки нейронной сети к обучению — это инициализация её весов. 🤷

Для справки: можете понимать нейронные сети как набор функций и матриц. Вот эти матрицы обычно называются весами. Т.к. слоёв в нейронной сети много — то и матриц тоже много (по крайней мере одна на слой). Тогда если X — это какой-то вход (картинка или что-то другое), а w — это веса на одном слое, то простейшая нейронная сеть — это fun(Xw), где fun — это какая-то функция.

Дело всё в том, что если в жизни для того, чтобы начать дело, нужно просто начать, то в машинном обучении нужно еще подготовиться к этому всему.🗿 Я опускаю моменты, связанные с подговкой данных, которые являются наиболее важными.

Допустим мы все сделали, написали весь код, подготовили данные, продебажили и поняли что всё в целом работает. И даже что-то учится и нейронная сеть выдает адекватные результаты☺️. Но не такие, какие хотелось бы. А еще учится просто ужасно долго (относительно 🥲). До первых адекватных результатов — 20 часов. 😢

Начинаем разбираться, как так, а что случилось? Или всё ок?🤔 И самая первая классика — забили/забыли/не подумали про инициализацию весов. Исправляем, запускаем и ого — теперь сеточка показывает первые результаты через 5 часов, а метрики уже показывают новые рекорды 💫. А казалось бы — какая-то инициализация весов, кто бы мог подумать.

В этом замечательном посте описано с формулами и картинками, почему важна инициализация весов.

А вам желаю я сходимости весов и градиентов без затуханий и взрывов!🤗

#разработка

C++ Zero Cost Conf 2022

Начиная с прошлого года я обязательно посещаю конференцию от Яндекса C++ Zero Cost Conf. Это возможность послушать бесплатно доклады от ребят, которые делают один из самых сложных и больших 🤯 highload на рынке России и, наверное, даже в СНГ. В этом году она будет 30 июля.

Я бы не стал выделять какие-то отдельные доклады, потому что сейчас программа выглядит очень сбалансировано и практически на все доклады можно попасть без перекрытий. Но лично я с удовольствием посмотрю на доклад от ClickHouse (просто люблю доклады от них). 😇

Регистрируйтесь на конференцию. Даже если вы не практикующий плюсовик, я думаю, вам будет интересно и полезно, как устроены сложные системы и с чем разработчики сталкиваются в большом highload! 🥷

#разработка

Addressof

Иногда, когда мы люди пишут библиотеки на C++ (можно сказать отдельный самодостаточный модуль приложения), важно строго следить за тем, что ты делаешь в коде 😅. Можно просто на раз два выстрелить себе в ногу 🗿: мы это уже видели в множестве постов выше (тык, тык). Вернемся к нашему любимому примеру:

class A {
public:
int *operator&() { return &b_; }
void Print() const { std::cout << a_ << ' ' << b_ << std::endl; }

private:
int a_ = 100;
int b_ = 200;
};

В нём я добавил один метод, о котором я расскажу позже. Как я уже рассказывал в посте, мы можем изменить приватные поля класса. Давайте изменим поле a_:

A a{};
a.Print(); // выведет 100 200
static_cast<int *>(static_cast<void *>(&a))[0] = 20;
a.Print(); // выведет 100 20

Странно, скажете вы 🤨. И правда — вроде обратились к первому элементу и хотели поменять его. А в итоге поменяли второй. Ну чушь какая-то. В чем же дело?

А проблема как раз в новом методе. Он переопределяет оператор взятия указателя &. Когда разработчик его переопределяет, вместо возврата указателя на область памяти, где лежит объект, будет вызван метод. А он возвращает указатель на b_. Поэтому и меняется значение b_ 😢.

Но как же избежать такого поведения? Неужели ребята из комитета C++ не продумали и оставили такую дыру? На самом деле нет — есть std::addressof — этот метод как раз и помогает нам избежать проблемы 🥷. Смотрите сами:

A b{};
b.Print(); // выведет 100 200
static_cast<int *>(static_cast<void *>(std::addressof(b)))[0] = 20;
b.Print(); // выведет 20 200

Это что, магия 💫??? Почему этот метод работает, а оператор & нет? Давайте подумаем, как можно такое написать. Для начала вспомним, что мы не можем писать оператор & перед переменной — это приведет к вызову переопределенного метода 🤓.

Можно было попробовать static_cast и const_cast, но там нужно как-то привести всё к void*. А этого мы сделать не можем, потому что не можем получить указатель. Остается reinterpret_cast. Предлагаю сделать тогда приведение к char &:

reinterpret_cast<char &>(b)

Почему здесь &? Потому что без него компилятор будет ругаться и говорить, что привести типы не может. Так устроен reinterpret_cast 😅. После преобразования мы получили ссылочный тип char& и вот от него можно получить уже указатель:

&reinterpret_cast<char &>(b)

Теперь нам осталось просто 🤗 превратить это в указатель на A. Делаем:

reinterpret_cast<A *>(&reinterpret_cast<char &>(b))

Поздравляю нас! Мы это сделали! Нооо.. Есть одна проблема ☺️. Допустим если переменная b — константная? Или volatile? reinterpret_cast в этом случае не будет работать. Чтобы обеспечить поддержку двух этих ключевых слов — нам нужно включить их в тип, т.е. сделать так:

reinterpret_cast<const volatile char &>(b)

Как вы поняли, мы тут не можем просто взять и превратить всё в A *. Нужно будет прокидывать ключевые слова const и volatile. А нам этого точно не нужно. К счастью, const_cast умеет их убирать. Тогда используя его, получим следующую реализацию addressof:

reinterpret_cast<A *>(const_cast<char *>(&reinterpret_cast<const volatile char &>(b)))

Вот теперь это будет работать в любом случае!☺️ Так эта функция примерно устроена в стандартной библиотеке. Я был очень сильно удивлен этому костылю 🤯!

В конце я хочу лишь сказать, что переопределять оператор & не стоит 🤨. Любой компилятор или статический анализатор подчеркнет и выведет предупреждение. Но порой необходимо делать такие вещи. А поэтому при разработке библиотек нужно учитывать даже такой, очень неявный момент.😓

P.S. Ссылочка на Godbolt

#разработка

Вы знаете, я не могу не поделиться этой новостью!