Грокаем C++

​​Зачем может понадобиться делать деструктор приватным? #новичкам Недавно мы узнали, что можно делать деструктор приватным. Те, кто не слышал о этой технике, скорее всего подумали: "Сомнительно........но.....окэй". Потому что с первого взгляда не очень понятно, для чего вообще нужно заниматься этими непристойностями in the first place. Чтобы запретить пользователю создавать объекты на стеке и в статической области? Ну и действительно, этот паттерн используется нечасто. Однако кейсы применения все же есть. Один из основных - ATL COM объекты. Их цикл жизни регулируется с помощью подсчета ссылок. И чтобы никто не смог удалить объект, на который все еще ссылаются ссылки, для объектов вводят приватный деструктор и метод Release. В нем происходит декремент ссылки, проверка их количества и удаление объекта, если он остался больше никому не нужным. Выглядеть это может примерно так:

int MyRefCountedObject::Release() 
{
  _refCount--;
  if ( 0 == _refCount ) 
  {
    delete this;
    return 0;
  }
  return _refCount;
}

Как можно было понять, это довольно устаревшая и нишевая виндовая история. Раньше паттерн подсчета ссылок внутри самого класса был более популярен. Теперь, в эпоху стандартных умных указателей, это скорее странное легаси. Помимо этого примера, для меня вообще довольно странная история, чтобы позволять какому-то коду создавать объект, но не позволять удалять его. Если я бы захотел контролировать удаление объекта, то с вероятностью 99% я бы захотел контролировать его создание. Чтобы так сказать стать черным властелином его цикла жизни. Поэтому, на мой взгляд, приватный деструктор должен идти вместе с приватным конструктором. Для синглтонов имеет смысл сделать деструктор приватным, чтобы никто по ошибке не смог явно вызвать на ссылке деструктор. Сам деструктор вызывается в статическом методе-геттере, который имеет доступ к приватным полям, тут все аккуратно работает. Также приватные конструктор и деструктор могут идти в комплекте с двумя статическими методами: Create() и Destroy(). Например, из Create возвращать умный указатель и указывать в качестве его делитера приватный статический метод Destroy. Таким образом вы можете реализовать довольно сложную логику создания и удаления объекта. Когда, например, у вас есть конструктор и метод init, то для ограничения работы с созданным, но не инициализированным объектом, используется статический метод Create. По аналогии для деструктора и finalize мы используем Destroy. Мы никого не ограничиваем в правильном создании и удалении объектов. Просто хотим, чтобы только через эти два метода проходило создание и удаление объектов.

class ControlLifeCycle
{
public:
  static std::unique_ptr<ControlLifeCycle, void()(ControlLifeCycle)> Create() // Factory
  {
    auto deleter = [](ControlLifeCycle * obj)
    {
      ControlLifeCycle::Destroy(obj);
    };
    std::cout << "I was born!" << std::endl;
    return std::unique_ptr<ControlLifeCycle, decltype(deleter)>(new ControlLifeCycle, deleter);
  }
private:
  static void Destroy(ControlLifeCycle* ptr)
  {
    std::cout << "I've been destroyed!" << std::endl;
    delete ptr;
  }
  ControlLifeCycle() {} // Private CTOR and DTOR
  ~ControlLifeCycle() {}
};

ControlLifeCycle global_var;                          // error: ctor and dtor are private

int main ()
{
    ControlLifeCycle stack_var;                          // error: ctor and dtor are private
    ControlLifeCycle* dynamic_var = new ControlLifeCycle;     // error: private ctor
    auto smart_var = ControlLifeCycle::Create();  // OK
}

Можно из метода Create возвращать просто указатель и оставить метод Destroy публичным. Тогда только мы своими очумелыми ручками сможем напечатать в нужном месте кода "Class::Destroy(ptr);" и только тогда произойдет освобождение ресурсов и ни в каком другом случае. В общем, эта техника может использоваться в любом месте, где нам необходим полный контроль над циклом жизни объекта и над способом его рождения и захоронения. Control cycle of your life. Stay cool.

ИБэшечка Ребятки, давайте на чистоту. Программирование - это конечно круто. Условия, циклы, архитектура, базы данных - все это интересно и весело. Но на этом далеко не уедешь. Самые востребованные специалисты сейчас - это не те люди, которые знают последний стандарт. Это конечно важно. Но настоящие чеки зашибают люди, которые шарят за свою предметную область. Количество информации сейчас растет как живот моего бати после 40-ка лет. Этот процесс уже не остановить. Но можно оседлать этого безудержного цифрового скакуна. Спросите как? А я вам отвечу. Любую информацию надо защищать. И чем ее больше, тем больше защитников для нее требуется. ИБ - это настоящее и будущее. Поэтому ловите два канала на тему ИБ и хакинга ZeroDay - Уроки по кибербезопасности и хакингу с нуля. Вирусы, взломы, OSINT, криптография и свежие новости. Там даже кошка научится разворачивать китайский файервол. Белый Хакер - программное обеспечение, утилиты, OSINT, инструменты, полезная литература и много другое. Совершенно новый формат непохожий на другие каналы. Можно и над мемасами покекать, и взламывать соседский вай-фай научиться. Входим в будущее подготовленными

Зато летает...

​​Приватный деструктор Все мы с вами знаем, что можно делать конструкторы приватными. Например, для синглтон паттерна такое используется. Или для запрета создания объекта класса никаким другим образом, кроме как вызовом статический метода Create. Раньше, до появления возможности удаления функций в С++11 с помощью =delete, конструктор копирования делали приватным, чтобы запретить внешнему коду возможность копирования объекта. Однако есть и симметричный сценарий, с которым вы явно не так часто сталкивались. Можно объявить приватным деструктор! Как это изменение отражается на поведении класса? Вот у нас есть класс. Там не будет ничего, кроме приватного деструктора. И дальше мы попытаемся посоздавать объекты этого класса.

struct CreationTest {
private:
  ~CreationTest() {};
}

CreationTest global_obj;

int main() {
  CreationTest auto_obj;
  CreationTest * dynamic_obj = new CreationTest;
  // delete dynamic_obj;
}

Пойдем по порядку. global_obj. Его конструктор вызывается в статической области памяти до вызова main. А деструктор по идее должен вызваться после завершения main в функции std::exit. Однако проблема: std::exit - внешний код для класса CreationTest, поэтому она не имеет право вызвать деструктор. Значит, на этой строчке будет ошибка компиляции. Вы не можете создавать объекты с приватным деструктором в статической области. Далее auto_obj. Память под этот объект выделяется на стеке и конструктор вызывается на этой памяти. А деструктор этого объекта вызывается после выхода из скоупа самим рантаймом. У которого опять нет доступа к auto_obj. Да чтож такое. Опять ошибка компиляции. Теперь dynamic_obj. Конструктор здесь вызывается самим оператором new, который в начале аллоцирует память и потом на этой памяти вызывает конструктор. С этим все хорошо. Но здесь намеренно допущена утечка, потому что если бы мы вызвали оператор delete, то и на этой строчке была бы ошибка. То есть динамическая область - единственное место, где мы нормально можем создавать объекты. Но без удаления этих объектов жить будет как-то грустновато. Утечки памяти, ее фрагментация. В общем ничего хорошего. Нужно решать проблему гениально! Я подключаюсь к Галилео Кто может получить доступ к приватным полям класса? Либо его методы, либо его кореша. То есть друзья. И это единственные сущности, которые помогут решить нам проблему. Покажу сразу оба варианта.

struct CreationTest {
  static void Destroy(CreationTest * obj) {
    delete obj;
  }
  friend void DestroyFunc(CreationTest * obj);
private:
  ~CreationTest() {};
}

void DestroyFunc(CreationTest * obj) {
  delete obj;
}

int main() {
  CreationTest * dynamic_obj = new CreationTest;
  CreationTest::Destroy(dynamic_obj);
  CreationTest * dynamic_obj1 = new CreationTest;
  DestroyFunc(dynamic_obj1);
}

Теперь все компилируется без проблем. Можно конечно немного позалупаться и создавать объекты через placement_new в автоматической области и также внутри функции вызывать деструктор, но это как будто бы борщ. Не очень удобно. Кстати, можно для таких динамических объектов использовать и умные указатели с кастомными делитерами, чтобы не беспокоиться о ручном управлении памятью.

auto deleter = [](CreationTest * obj) {DestroyFunc(obj);};
std::unique_ptr<CreationTest, decltype(deleter)> smart_obj(new CreationTest, deleter);

В следующем посте поговорим о том, зачем вообще может понадобиться делать конструктор приватным. Protect your private life. Stay cool. #cppcore #cpp11

Foodtech tour Яндекса возвращается: стартуем с митапом в Москве 19 сентября! В программе суровая энтерпрайз-разработка для опытных бэкендеров. Эксперты расскажут о работе с монолитами на примере Еды и переосмыслении процессинга заказов в Лавке. От Маркета заявлен воркшоп с архитектурными кейсами: без практики точно не останемся.  Foodtech tour охватит 4 столицы: Москва — 19 сентября, Санкт-Петербург — 17 октября, Казань — 14 ноября и Минск — 5 декабря.  👉🏻 Регистрируйтесь в своём городе!

Ковариантные возвращаемые типы Есть такое интересное понятие, о котором вы возможно ни разу не слышали. Пример из поста выше с методами clone и create можно было написать иначе:

class Shape {
  public:
    virtual ~Shape() { } // A virtual destructor
    // ...
    virtual Shape* clone() const = 0; // Uses the copy constructor
    virtual Shape* create() const = 0; // Uses the default constructor
};
class Circle : public Shape {
  public:
    Circle* clone() const override;
    Circle* create() const override;
    // ...
};
Circle* Circle::clone() const { return new Circle(this); }
Circle* Circle::create() const { return new Circle(); }

Вы скажете: "Сигнатуры не совпадают! Код не скомпилируется!". А я скажу: "Shape и Circle - ковариантные типы". С++ разрешает наследнику переопределять методы с возвращаемым типом, который является наследником типа метода из базового класса. Говорят, что это даже называется идиомой С++. Какие юзкейсы у этой идиомы? По факту всего один. Представьте, что все методы возвращают один тип Shape. Вы создали объект Circle в куче и присвоили указатель на него к указателю на Circle. Тогда при клонировании объекта Circle вам вернется указатель на объект базового класса. И по хорошему его надо динамик кастить к Circle, чтобы работать с конкретным типом наследника. А это оверхэд:

Circle *circle1 = new Circle();
Shape *shape = d1->clone();
Circle *circle2 = dynamic_cast<Circle *>(shape);
if(circle2) {
  // Use circle2 here.
}

Выглядит не очень. Посмотрим, как изменится код, если методы Circle будут возвращать указатель на Circle:

Circle *circle1 = new Circle();
Circle *circle2 = d1->clone();

Выглядит намного лучше. Но вот вопрос: почему вы нигде не увидите в коде применения ковариантных типов? Потому что этот подход не работает с умными указателями, которые де факто являются стандартом при возвращении объектов из фабрик. std::unique_ptr<Circle> не является наследником std::unique_ptr<Shape>, поэтому они и не ковариантные типы и сигнатуры методов будут несовместимы. Возвращение сырых указателей - супер bad practice, один только этот факт заставляет отказаться от такого подхода. Тем более полиморфные объекты и придумали для того, чтобы использовать их полиморфно. То есть через ссылку или указатель на базовый класс. Зачем оперировать полиморфным объектом с указателем на конкретный тип - не очень понятно. Раньше, до изобретения умных указателей, идиома была легитимна. Теперь же она отправилась на свалку истории. Только что вы прочитали очередную статью про совсем ненужную хрень. Ставьте 🗿, если ваше лицо сейчас на него похоже) Stay poker-faced. Stay cool. #fun #cppcore

​​Виртуальный конструктор #новичкам Виртуальные методы - это основа полиморфизма, одного из важнейших концептов объектно-ориентированного программирования, который позволяет нам реализовывать сложные конструкции из классов и строить гибкую-расширяемую архитектуру. Но вот если на секунду задуматься: конструктор - это ведь тоже метод. Можем ли мы сделать конструктор класса виртуальным? Один из тех самых популярных вопросов на собеседованиях, который не проверяет никаких практически применимых знаний. Он скорее направлен больше на понимание концепции ООП и механизма создания объектов в С++. Ответ: нет, не можем. Логика тут довольно простая. Виртуальные функции подразумевают собой позднее связывание объекта и вызываемого метода в рантайме. То есть для них нужны объекты(точнее vptr, которых находится внутри них). А объекты создаются в рантайме. И для создания объектов нужны констукторы. Получается, если бы конструкторы были виртуальными, то собака постоянно гналась бы укусить себя за жёпу получился бы цикл и парадокс(фанатам Шарифова посвящается). Нет указателя на виртуальную таблицу - нет виртуальности. Если более формально и официально, то вот комментарий самого Бъерна по этому вопросу:

A virtual call is a mechanism to get 
work done given partial information. 
In particular, "virtual" allows us to 
call a function knowing only an interfaces 
and not the exact type of the object. 
To create an object you need complete 
information. In particular, you need to 
know the exact type of what you want to 
create. Consequently, a 
"call to a constructor" cannot be virtual.

Виртуальный вызов — это механизм выполнения работы при наличии частичной информации. В частности, он позволяет нам вызывать функцию, зная только тип базового класса, а не точный тип объекта. Для создания объекта необходима полная информация. В частности, вам необходимо знать точный тип того, что вы хотите создать. Следовательно, «вызов конструктора» не может быть виртуальным. Однако, нам по сути этого и не нужно. Нам нужен механизм создания объекта, зависящий от типа полиморфного объекта. И у нас такой механизм есть! Называется он фабричным методом. В ту же степь идет и паттерн "метод clone()". В сущности, фабричный метод позволяет создавать объекты, тип которых зависит от типа объекта, у которого вызывается метод. Метод clone позволяет создавать объекты именно того класса, который на самом деле лежит под данным указателем или ссылкой. Выглядит это так:

class Shape {
  public:
    virtual ~Shape() { } // A virtual destructor
    // ...
    virtual std::unique_ptr<Shape> clone() const = 0; // Uses the copy constructor
    virtual std::unique_ptr<Shape> create() const = 0; // Uses the default constructor
};
class Circle : public Shape {
  public:
    std::unique_ptr<Shape> clone() const override;
    std::unique_ptr<Shape> create() const override;
    // ...
};
std::unique_ptr<Shape> Circle::clone() const { return new Circle(*this); }
std::unique_ptr<Shape> Circle::create() const { return new Circle(); }

У класса Фигура есть метод clone, который позволяет скопировать текущий объект в новый объект. Метод create позволяет дефолтно создать объект того же класса. В класса Circle эти методы переопределяются. Теперь можно не зная точного типа полиморфного объекта вызвать его конструктор по умолчанию и копирования.

std::unique_ptr<Shape> ptr = std::make_unique<Circle>();

auto new_obj = ptr->create();

auto copy_obj = ptr->copy();

В эти методы также можно добавить аргументов, в том числе и полиморфных типов. Главное, чтобы сигнатуры методов в наследниках и базе совпадали. Можете кстати порассуждать в комментах, как бы выглядели виртуальные конструкторы и код, который бы их использовал. Use well-known tools for your task. Stay cool. #interview #cppcore #pattern

Станьте AI-разработчиком на Python и зарабатывайте от 150.000₽ в месяц 🔥🔥🔥 Мы научим вас создавать и тренировать нейронные сети, и вы сможете: 1️⃣ Устроиться разработчиком в крупную компанию и зарабатывать от 150 тыс. ₽ в месяц 2️⃣ Разрабатывать такие проекты на заказ и зарабатывать от 500 тыс. ₽ за проект 3️⃣ Создать нейро-сотрудника в вашей компании и вырасти на +30-100% в зарплате На интенсиве будет много практики: создадим 9 нейросетей за 1 вечер: 🧬 Оценка выброса CO2 по параметрам машины 🧬 Сегментация изображения для робота доставщика 🧬 Трекинг людей на видео 🧬 Распознавание речи и другие Ведущий интенсива - Senior AI-разработчик и основатель Университета искусственного интеллекта 🔥 Регистрируйтесь на бесплатный интенсив! Встречаемся в ближайшую среду. Вы узнаете, как освоить самую востребованную профессию и гарантированно зарабатывать!

​​Фактор загрузки std:unordered_map #новичкам Все мы знаем, как растет в размерах вектор с увеличением количества элементов. Может быть мы в конкретном случае не знаем мультипликатор увеличения вектора, но механизм мы понимаем. Но например, неупорядоченная мапа - немного другой фрукт. За счет того, что мы сами можем предоставить свою хэш-функцию для нее, мы очень сильно можем влиять на поведение контейнера. Буквально все похерить плохим хэшом или сделать все по-красоте. Однако не всегда плохой хэш - действительно очень плохой. Может он и плохонький, но зато очень быстрый. Возможно, за счет этого будет много хэш-коллизий и появится проблема кластеризации. Но нам это может быть и не так важно, если у нас есть действительно быстрый хэш. Таким образом мы реально влияет, если не на внутреннее устройство контейнера, то на тенденции фактического расположения элементов. Такая возможность кастомизации должна идти вместе с влиянием на поведение мапы при увеличении размеров. У вектора есть поле - capacity, которое говорит о том, сколько элементов может вмещать внутренний буффер. Мапа же за счет своей бакетной структуры может вмещать сколько угодно элементов. Но нам не хотелось бы прийти к ситуации, когда мапа вырождается в набор огромных связных списков. Поэтому для нее также должна быть какая-то эвристика, которая поможет предотвратить такую проблему, своевременно увеличивать размер внутреннего массива-хэш-таблицы и перехэшировать элементы.

float load_factor() const;

Этот метод мапы возвращает ее фактор загрузки, который равен среднему числу элементов в одном бакете aka size() / bucket_count(). Эта та характеристика, которая определяет, когда мапа будет расширяться. Точнее не только она. Нужно же еще пороговое значение, при достижении которого произойдет расширение. А вот и оно.

float max_load_factor() const;
void max_load_factor( float ml );

Максимальный фактор загрузки определяет максимальное среднее число элементов в бакетах, после достижения которого произойдет расширение хэш-таблицы. И обратите внимание, что мы сами можем влиять на это значение! Реализация безусловно предоставляет свое значение(скорее всего 1). Но с помощью экспериментов со своей хэш-функцией и кастомным лоад фактором, вы можете добиться по-настоящему желаемого поведения этого непростого контейнера. Stay balanced. Stay cool. #STL #cppcore

​​Вызываем оператор индексации у указателей Есть суперважная проблема, с которой сталкиваются 100% разработчиков в каждой строке своего кода. Для указателей перегружен оператор квадратные скобки, который сдвигает указатель на величину индекса вправо и разименовывает его. И вот теперь представим, что у нас есть класс с собственным перегруженным оператором[]. Например, std::deque. У нас каким-то образом в руках появился указатель на экземпляр этого контейнера. Как у него вызвать оператор взятия индекса объекта? Если сделать так:

std::deque<int> * deque_inst = new std::deque<int>{1, 2, 3, 4, 5};
std::cout << deque_inst[4] << std::endl;

то получите огромную простыню нечитаемых ошибок компиляции. Все потому что deque_inst - это указатель, а deque_inst[4] значит "сдвинь указатель на 4 вправо и разыменуй". И шо делать? Так же не напишешь:

deque_inst->[3]

Немного не очень опытных разработчиков знают, что можно вызывать операторы явно. Так вот в этом случае как раз можно вызвать оператор[] явно:

std::deque<int> * deque_inst = new std::deque<int>{1, 2, 3, 4, 5};
std::cout << deque_inst->operator[](3)<< std::endl;

Ну то есть все как обычно: есть указатель на объект, мы вызываем у него метод через оператор доступа к членам (для пролетариев - оператор стрелочка). Но этот метод - сам оператор и мы просто вызываем его согласно сигнатуре. Такой вот прикол. Иногда может выручить. Однако nobody knows зачем и как вы получили указатель на объект с переопределенным оператором[]. Возможно, вам стоит пересмотреть организацию вашего кода. Express your thoughts explicitly. Stay cool. #cppcore

И ведь приходится разворачиваться....

​​Зачем вообще нужен кастомный swap? Коротко - незачем) Но как всегда есть нюансы. Забайтились? Погнали разбираться. Как всю историю человечества разделяет Рождество Христово, так и история С++ делится на две эпохи появлением стандарта С++11. Получается, что С++11 - Иисус в мире плюсов... И вот до С++11 мы не имели семантики перемещения и функция std::swap обменивала два значения через копирование. Ну и естественно это никому не нравилось. Зачем такой оверхед, когда мне нужно только местами данные поменять? И вот в те времена кастомная функция swap была как нельзя кстати. Именно поэтому std::vector имеет отдельный метод swap. Рудимент архаичного прошлого... С тех пор все стандартные алгоритмы в первую очередь ищут use-defined swap и уже на крайняк используют std::swap. Если ваш класс управлял хоть каким-то ресурсом, даже строкой, вам нужен был свап. Но по сути-то, свап - это такой одновременный мув друг в друга(идейно). Ну и с появлением мув-семантики стандратная swap стала выглядеть именно так, как нам нужно идейно:

template <typename T>
void swap(T& x, T& y)
{
    T temp(std::move(x));
    x = std::move(y);
    y = std::move(temp);
}

Эта версия свапа делает ровно то, что ожидали практически от всех кастомных swap'ов - эффективный обмен двух значений. Она позволяет даже некопируемым объектам, типа стримов, мьютексов и прочих, обменяться местами. То есть она буквально отобрала весь хлеб у кастомной swap: теперь стандратная функция делает такой же эффективный обмен значениями, плюс может также обменять некопируемые объекты. Красота! Но у самописной swap остается одно преимущество: Не происходит никаких вызовов конструкторов классов обмениваемых объектов. Мы напрямую обмениваем содержимое объектов. А std::swap все-таки вызывает один мув-конструктор и 2 мув присваивания. О производительности надо думать... А еще надо думать об оптимизациях компилятора. Специальные методы могут быть заинлайнены и std::swap превратится ровно в то же, что сгенерирует компилятор для вашей самописной обменивалки. Также некоторый легаси код может использовать в своих кишках именно метод swap, поэтому чтобы пользоваться этим кодом, нужно реализовывать метод. Но это не то, что бы частая история. Итог какой: кастомный своп был придуман, в основном, чтобы эффективно обменивать объекты. std::swap на стероидах мув-семантики позволяет делать это очень эффективно. Самописный своп имеет на первый взгляд незначительные преимущества по производительности. Но на практике как всегда надо тестировать оба варианта. Ну или не заниматься преждевременной оптимизацией и использоват std::swap. Use standard things. Stay cool. #cppcore #cpp11

Курс «Реверсивный инжиниринг ПО под ОС Windows» стартует 9 сентября! В курсе подробно рассматривается синтаксис Ассемблера, анализ приложений различного уровня сложности, от простейших crackme до полноценных программ на современных архитектурах. Необходимые знания: язык Ассемблера, С/С++, python, навыки работы с IDA и другими инструментами для реверса Вы получите: - Сертификат/удостоверение о повышении квалификации - Сопровождение и поддержку Академии Кодебай - Возможности трудоустройства/стажировки Пишите нам @Codeby_Academy Подробнее о курсе → здесь

std::swap и ADL В коммьюнити есть определенное заблуждение, что когда мы вызываем std::swap для наших кастомных типов, эта функция в начале ищет через ADL самую подходящую перегрузку, которую мы возможно определили, и только в случае неудачи вызывается дефолтная реализация обмена. Это конечно не так и вот причины. Первая, довольно косвенная. Все алгоритмы стандартной библиотеки никогда не используют вызов std::swap напрямую для обмена элементов последовательности. Там все делается как в предыдущем посте с помощью using std::swap, чтобы как раз разрешить ADL найти самую подходящую перегрузку. Зачем это делать, если std::swap и так самостоятельно ищет через ADL? Вторая - подобная реализация std::swap вгоняет в бесконечную рекурсию следующий код:

namespace ns
{
  struct foo
  {
    foo() : i(0) {}
    int i;
  };
  void swap(foo& lhs, foo& rhs)
  {
    std::swap(lhs, rhs);
  }
}

template <typename T>
void do_swap(T& lhs, T& rhs)
{
  std::swap(lhs, rhs);
}

int main()
{
  ns::foo a, b;
  do_swap(a, b);
}

Неважно хороший ли это код или нет, он может встречаться в проектах. Зачем определять свою функцию swap через std::swap - загадка, но это работает. Почему вообще должно быть важно, что работает такой плохой код? Потому что обратная совместимость. Такой код вполне мог существовать и использование ADL внутри std::swap его бы сломало. Тем не менее были предложения в стандарт, которые предлагали разрешить ADL внутри std::swap. И они вроде даже попали в драфт С++20, но в сам стандарт так и не вошли. Думаю, что в том числе и по причине обратной совместимости. Так что для правильного свопа необходимо приписывать using std::swap. Или нет? Я уже говорил, что в стандартной библиотеке алгоритмов не используется обмен элементов последовательности через std::swap. Но не сказал, как именно. А обменивают их через std::iter_swap(логично, там же итераторы используются). И вот его возможная имплементация:

template<class ForwardIt1, class ForwardIt2>
constexpr //< since C++20
void iter_swap(ForwardIt1 a, ForwardIt2 b)
{
    using std::swap;
    swap(*a, *b);
}

То, что нужно! Теперь можно писать так:

struct my_type
{
    friend void swap(my_type& first, my_type& second) noexcept {
    std::iter_swap(&first.member_1, &second.member_1);
    std::iter_swap(&first.member_2, &second.member_2);
  }
  Type1 member1;
  Type2 member2;
};

Немного корявенько, зато думать не надо. Ну или можно бустовскую версию свапа взять, которая делает примерно то же, что и iter_swap. Но надо ли вам тянуть буст - это вопрос. Properly exchange values. Stay cool. #cppcore

Знаете ли вы, что число π (пи) никогда не заканчивается и не повторяется? А числа Фибоначчи встречаются во многих природных явлениях? 🐌 Математика — это не просто набор формул. Это язык, который описывает мир вокруг нас. 📚 Есть желание разобраться? В помощь вам — полезный канал о высшей математике. Его автор — выпускник СПБГУ, а ныне — преподаватель предмета. Простым языком объясняет сложные вещи, даёт шпаргалки и проводит бесплатные практикумы 🔥 Приятный бонус — живые дискуссии в комментариях и ответы на любые вопросы. Посмотрите сами 👉 @lav_math

Теперь всякий раз, когда какой-нибудь зеленый неокрепший птенец, мечтающий стать гордым плюсовым орлом, будет вас спрашивать "Что такое указатель?" - вы знаете, что ему показать.

​​Результаты ревью Всем большое спасибо за активность, было интересно почитать ваши замечания/вопросы/споры/предложения. Выявились 2 явных лидера по объему найденных недостатков. Так как рассуждения у них были объемные и не строго структурированные, то упомяну обоих. Давайте похлопаем Дмитрию и Михаилу👏👏👏👏 Теперь саммари по пунктам: ❗️ Используется странный стиль глобальные переменные + функции. Много чего можно объединить и/или завернуть в классы. ❗️ Если уж используете глобальные переменные в цпп файле(а это скорее всего он и есть), то используйте пометку static, чтобы не засорять именами скоуп. К функциям это тоже относится. ❗️ Обильное использование сырых указателей на объекты класса. В данном случае это точно code smell и все нужно переделать на умные указатели. ❗️ Бессмысленно использование более сложного гарда std::unique_lock. Обычно он используется в тандеме с кондварами. Здесь будет достаточно std::lock_guard и выделение отдельного скоупа критической секции с помощью фигурных скобок {}. ❗️ Странное завершение цикла при достижении конца очереди. Это накладывает на вызывающий код ответственность за обработку этой ситуации. Конкретно в таком простом варианте очереди на мьютексте логично оставить цикл бесконечным и при достижении конца продолжать цикл заново. ❗️ Странный слип под локом в DequeueJob. Слишком жирно потоку преднамеренно спать с загробастанным мьютексом. Наверное автор просто не подумал, но все же так делать не надо и этот слип нужно вынести из критической секции. ❗️ Странный принт под локом EnqueueJob. Слишком долгая операции и семантически не относящаяся к критической секции. Нужно вынести за пределы лока. ❗️ Странный выбор контейнера для очереди. Если уж так не хочется писать свой класс, то в STL есть прекрасный std::queue, который как бы прям прыгает с экрана монитора и говорит: "Нужна очередь и выбираешь не меня? Больной ублюдок..." ❗️ Так как NewJob - довольно маленькая структура, то передавать ее везде можно по значению, вместо указателей. Ну или сразу использовать std::unique_ptr с заделом на будущее ообогащение задачи. ❗️ Нет graceful завершения обработки очереди. Нужно как-то обрабатывать ситуацию, когда нам захочется закончить разгребать очередь и возможно сделать еще какие-то действия, но мы не хотим это делать через простой head shot приложения. ❗️ Стандартный подход к написанию очередей - использование кондваров. Консюмер спит до тех пор, пока продюсер не уведомит его о наличии новой задачи. Пример можно посмотреть тут. ❗️ Архитектурные решения в этом коде довольно бедные. Понятно, что код простой и не претендует на высокие материи и на место на обложке Cosmopolitan. Но хоть что-то же должно быть. По дизайну видение у всех может быть разное, но тут явно все хромает. ❗️ Уж не буду отдельными пунктами упоминать мелкие странные вещи типа "delete job, job = Null" или конструктор для простой структуры(можно агрегатную инициализацию использовать), юзинг и тд. Итого довольно внушительный список получился. Конечно, это не продовый код и писал его человек явно в начале своего пути знакомства с многопоточкой и плюсами в целом. Так что не судите строго этого маленького китайского мальчика. Никто не родился вундеркиндом по С++. "Исправленную версию" можете найти в комментах. Fix your flaws. Stay cool.

​​Ревью Продолжаем разбирать примеры существующего кода и совместно выявлять в них проблемы. Сегодня будет не самый продовый пример, но интересный по многим моментам. В основном, из-за многопоточки. Призываю всех участвовать в обсуждении и писать свои варианты того, что в этом коде не так и как это можно улучшить. Начинающие может пока совсем не поймут, что здесь происходит. Но вот продолжающим будет очень полезно почитать ваши рассуждения и узнать много нового. Не обязательно писать большие тирады или искать заковыристые проблемы. Если вы нашли ошибку - поделитесь ей в комментах. Это отличная практика код #ревью. Кусок кода прикреплю картинкой к посту. Объединенный разбор опубликую завтра. Как всегда, самые продуктивные ревьюеры будут упомянуты в этом разборе. Analyse your life. Stay cool.

​​Правильный swap двух объектов Ч2 В прошлый раз мы разобрались, почему swap лучше всего определять через дружественную функцию. Сегодня разберем то, что должно быть у нее внутри. Очень хочется написать просто типа такого:

struct my_type
{
    friend void swap(my_type& first, my_type& second) noexcept {
      std::swap(first.member_1, second.member_1);
      std::swap(first.member_2, second.member_2);
  }
  Type1 member1;
  Type2 member2;
};

И это работает для тривиальных типов Type1, Type2. Если у вас тривиальные члены - пожалуйста пользуйтесь. Но если Type1, Type2 - пользовательские типы не из стандартной библиотеки? Понятное дело, что для стдшных типов есть специализации std::swap. Но вот для обычных смертных - нет. И если для этого смертного типа определена своя функция swap, которая лучше знает, как обменивать данные, то таким образом вы никогда ее не вызовете. А если какой-то из ваших мемберов не удовлетворяет условию std::is_move_constructible_v<T> && std::is_move_assignable_v<T>, то вы вообще не скомпилируете этот код. Выход - нужно как-то разрешить искать функцию swap в неймспейсе класса. Так как она более специализирована под ваш конкретный тип, то она будет предпочтительнее, чем стдшная, и будет вызываться вместо него. Такая штука есть и называется она ADL или Argument Dependent Lookup. С ее помощью мы можем найти нужную функцию по типу аргумента. Можно написать:

struct my_type
{
    friend void swap(my_type& first, my_type& second) noexcept {
      swap(first.member_1, second.member_1);
      swap(first.member_2, second.member_2);
  }
  Type1 member1;
  Type2 member2;
};

И если для Type1 и Type2 определены свои функции swap, то они найдутся и все скомпилируется. Однако выискивать для каждого типа своего мембера, есть ли у него своя собственная swap - задача неблагодарная. Хотелось бы и рыбку съесть и машку за ляшку не задумываться о выборе нужной функции и положить эту задачу на плечи компилятора. И это можно сделать!

struct my_type
{
    friend void swap(my_type& first, my_type& second) noexcept {
      using std::swap;
      swap(first.member_1, second.member_1);
      swap(first.member_2, second.member_2);
  }
  Type1 member1;
  Type2 member2;
};

Какая тут магия произошла. Мы попрежнему используем ADL для поиска наиболее подходящей функции. Но если мы ее не нашли, то остается бэкап в виде std::swap, которая может вызваться благодаря using std::swap. Примерно так и выглядит "каноничный" вид функции swap для ваших кастомных классов. Sit on both chairs. Stay cool. #cppcore

Что получится, если к С++ добавить Яндекс Практикум? Курс для будущих разработчиков! Сервис онлайн-образования Яндекс Практикум в поисках программного эксперта и наставника для студентов. Нужен Middle-специалист с опытом работы от трёх лет. Если у вас есть 2-3 часа свободного времени ежедневно и огромное желание делиться экспертизой, то добро пожаловать в команду! Почему это интересно: • удалёнка и дополнительный доход; • благодарная аудитория, возможность самореализации; • энергичное комьюнити и коллеги, с которыми не скучно. Узнать подробности и откликнуться: → наставник на курсе «Разработчик С++», → программный эксперт Давайте вместе менять индустрию!