А вы знали? Дробные числа нельзя сравнивать!
Точнее проверять равенство между ними.

Как вы обычно сравниваете числа? Самый простой способ сравнения - это написать num1 == num2 в условии, где это нужно. Это достаточно очевидно, но, к сожалению, ведёт к неочевидным и странным последствиям.

Равны ли числа 1 и 1.1? Очевидно, нет. А равны ли числа 1 и 1.001? Тоже вроде нет. А если мы сравним 1 и 1.0000000001? Вроде эти два числа очень-очень близки, но даже такое маленькое различие делает их разными. Так работает равенство чисел в арифметике.

А что насчёт программирования?

Вы ведь знаете, что числа в памяти хранятся с определённой ограниченной точностью? Все числа в C++ занимают определённое конкретное количество байт памяти, которое зависит от типа данных. У целых чисел это влияет на диапазон возможных значений, а у чисел типа float на точность этих самых чисел.

Из-за этого могут возникнуть такие ситуации, что, казалось бы, числа, которые должны быть одинаковыми, имеют очень маленькое различие, из-за чего считаются разными. При выводе через cout мы не увидим этой разницы, но она всё равно повлияет на результат сравнения.

Давайте представим простой пример:

cout << boolalpha; // Для вывода true/false вместо 1/0

float num = 1.0 / 3;

cout << (num * 3.0 == 1); // 1/3*3 == 1

Этот код выведет false. То есть мы по сути нашли доказательство того, что 1 иногда не равен 1. Из-за неточностей вычислений эти два числа оказались разными, хотя cout оба числа выведет как 1.

Ещё один пример:

cout << boolalpha;

cout << (1.1 + 2.2 == 3.3);

Здесь тоже выведется false. Это уже похоже на какой-то абсурд.

Примечание: Вывод этих примеров зависит от выбранного компилятора, от платформы, на которой запускается код, и от точности вычислений процессора.

Лучшее решение - это просто использовать операторы < и > вместо ==. Например, следующим образом:

// Если разница между числами меньше, чем 0.001
if (abs(a - b) < 0.001)
    ...

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

#интересные_факты

Как интересно наблюдать такие графы в процессе разработки!

Если вдруг кому неизвестно, я намерен создать курс-продолжение по C++ и охватить в нём такие темы, как указатели, ООП и т.п.

Любой курс - это в первую очередь программа курса.

Чтобы составить программу, то есть написать список тем и уроков и расположить их в определённом порядке, я составил такую вот mind-карту с различными темами, их очерёдностью и взаимодействием.

Сверху находятся темы из предыдущего курса, а снизу - из следующего. Новые темы уже могут сравниться по количеству со старыми, а ведь ещё осталось много того, что ещё стоит добавить.

В общем, у кого как, а у меня ожидается весьма насыщенный год. Повезёт, если это чудо хотя бы в 40 уроков уложится.

#опланах

Кажется, мы определились с программой курса!

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

Вот список уроков следующего курса:

1. Введение
   1. О курсе
   2. Про среды разработки (тут мы установим IDE)
   3. Шпаргалки (тут будут шпаргалки по всем урокам)
2. Повторяем пройденное
   1. ... (тут мы повторим основы C++)
3. Больше по числам (?)
   1. Больше по числам
   2. Тернарный оператор
   3. Приведение типов
   4. Битовые операции
4. Управление памятью
   1. Указатели
   2. Ссылки на объекты
   3. Указатели в массивах
   4. Создание объектов
   5. Умные указатели
5. Основы ООП
   1. Структуры из C
   2. Классы в C++
   3. Доступ к атрибутам
   4. Перегрузка методов
   5. Конструкторы/деструкторы
   6. Перегрузка операторов
6. Про кодовые базы
   1. Поля имён
   2. Препроцессор
   3. Заголовочные файлы
   4. Фишки в IDE
   5. Функция main
   6. Процесс трансляции
7. Структуры данных
   1. Итераторы
   2. Векторы (std::vector)
   3. Сортировка массивов
   4. Очередь и стек (std::deque)
   5. Множества (std::set)
   6. Классы std::tuple и std::pair
   7. Маппинги (std::map)
8. Больше по ООП
   1. Копирование объектов
   2. Наследование
   3. Полиморфизм
   4. Приведение типов в ООП
   5. Шаблоны
   6. Перечисления

В этой программе мне остаётся непонятным только одно - как назвать модуль №3. Он явно не только о числах, ведь в нём есть тема тернарного оператора. Да и к тому же название модуля дублирует название урока. Может у вас будут варианты, как назвать этот модуль?

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

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

На данный момент в программе 38 уроков. Судя по моим подсчётам, если выделять по 6 дней на каждый урок, создание курса будет завершено 22 августа. Теперь вы знаете, какую дату нужно ждать.

#опланах

Я немного изменил программу модуля №3

Урок «Больше по числам» теперь разделён на 2 урока: «Целые числа» и «Числа с плавающей точкой». Ещё я вытащил из урока «Приведение типов» тему спецификатора const и приведения const_cast в отдельный урок.

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

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

Я тут создаю урок про побитовые операции, и сейчас немного удивляюсь, насколько большим получается текст теории. На данный момент получается свыше 2000 слов, а ведь я ещё не написал разделы про операторы &, |, <<, >> и ^.

Урок «Битовые операции» по плану должен содержать следующие темы:

• Список арифметических операций
• Двоичное представление чисел
• Побитовые логические операции: ~, & и |
• Битовый сдвиг: << и >>
• Исключающее «ИЛИ» и побитовое XOR: ^

Сейчас я вижу два варианта решения проблемы большого текста теории:

• Уменьшить часть конспекта про двоичную систему счисления, в итоге оставив эту тему немного нераскрытой
• Вынести её в отдельный урок (тогда придётся рассматривать её подробно и добавлять задачи)

Двоичная с.с. сейчас занимает почти пол-урока и вполне себе является отдельной темой для изучения.

Проблема заключается лишь в том, что какая-то часть людей может не захотеть проходить урок про двоичную с.с. и посчитать эту тему немного тошнотворной. Поэтому оставляю это решение на вас.

Вы когда-нибудь пользовались указателями?

Язык C++ и программы, написанные на нём, являются очень быстрыми. C++ является очень низкоуровневым языком, что позволяет программистам работать с памятью на самом фундаментальном уровне и тем самым значительно оптимизировать программы.

Одним из инструментов для работы с памятью являются указатели.

Указатель – это числовое значение, обозначающее адреса какого-то значения в памяти.

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

Указатели в C++ с точки зрения типов данных указывают на объекты разных типов, а не на байты. То есть существуют указатели на числа, на символы, на строки, и всё это разные указатели.

Вот, как можно объявить указатель:

// Указатель на объект типа int
int* pointer;
// «pointer» переводится как «указатель»

Чтобы указатель хранил какой-то адрес, а не, как мы говорим, белиберду, его нужно инициализировать.

Для этого нужно получить адрес объекта, на который должен указывать указатель:

int number = 3;
int* pointer = &number;

Значок & означает, что мы берём адрес объекта (числа), который хранится в переменной number.

Мы можем вывести указатель, и тогда выведется адрес переменной number:

cout << pointer; // -> 0x7ffee4981224

Вывелся адрес в шестнадцатеричном виде. Это тоже число, и мы можем его перевести в десятичный вид (140732733592100), но обычно адреса записываются именно в шестнадцатеричном виде, ведь так удобнее.

Теперь мы можем работать с переменной number через этот указатель:

// *pointer - это получение указываемого объекта
// т.е. получение переменной number
cout << *pointer << endl  // -> 3
     << number   << endl; // -> 3

// Изменяем number через указатель
*pointer = 13;

cout << *pointer << endl  // -> 13
     << number   << endl; // -> 13

Таким образом мы продолжаем работать с переменной number, просто используем для этого её адрес, а не саму переменную.

Грамотное использование указателей в коде позволяет значительно ускорять программы. Однако для этого требуется достаточно знаний об указателях.

Нееет! Опять эти сложные и непонятные указатели!

На самом деле указатели – это весьма простая абстракция, которая ложится на фундаментальную работу памяти и немного на систему типов данных в C++. Чтобы хорошо знать указатели, нужно погрузиться в работу памяти, и именно это обычно вызывает все трудности при изучении.

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

#интересные_факты

Вы когда-нибудь слышали о const в C++?

С помощью спецификатора const мы можем пометить, что объявляемая переменная не будет изменяться. Так любая операция изменения переменной приведёт к ошибке.

Сокращение const происходит от constant - постоянный

Мы должны указывать слово const в типе данных переменной:

const int number = 15;
const float pi = 3.14;

Можно сказать, что number имеет тип const int, а pi – const double. Слово const влияет на поведение значения переменной, а не самой переменной, поэтому оно является частью типа данных.

const int length = 13;

length = 15; // ошибка
// нельзя изменять const переменные

cin >> length; // тоже ошибка
// cin присваивает length новое значение

// а это не вызовет ошибки
int new_length = length + 2;
// здесь мы не меняем значение length

При объявлении const переменных их обязательно сразу инициализировать:

const int number; // Ошибка
// нужно сразу инициализировать const переменную

Мы можем выносить некоторые "магические числа" в отдельные переменные, улучшая читаемость кода.

float radius;
cin >> radius;

float length = 6.28 * radius
cout << length;

Людям, которые плохо знакомы с математикой, может быть неясно, что такое 6.28. Ведь это просто магическое число, которое, казалось бы, не имеет никакого смысла.

Лучше переписать этот код через const переменные:

const float pi = 3.14;

float radius;
cin >> radius;

float length = 2 * pi * radius
cout << length;

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

Вынося "магические числа" в const переменные, мы можем значительно увеличить понятность кода.

Спецификатор const позволяет:

• Защитить переменные от случайного изменения
• Увеличить понятность кода засчёт вынесения магических чисел
• Прояснять назначение некоторых переменных, например, численных идентификаторов

Также const переменные могут быть оптимизированы компилятором. В C++ при автоматической оптимизации кода часть операций производится на этапе компиляции, поэтому const переменные иногда могут быть удалены из скомпилированной программы.

#интересные_факты