Нас обманывали, а мы и не заметили (Часть 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

#разработка

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