res2001

Если вы делите целые числа (short, int, long), то на компьютере вы в принципе не можете получить число с плавающей точкой в результате, т.к. выполняете целочисленное деление.
Кроме того в процессоре целочисленное деление на ноль обычно вызывает аппаратное исключение. Оно может передаваться в приложение, может не передаваться, тут уже особенности платформы, runtime и т.п. Можете поэкспериментировать.

Деление на ноль чисел с плавающей точкой стандартно дает в результате NaN - это не число (Not a Number). Любые дальнейшие операции с NaN будут давать в результате NaN.
Современная стандартная библиотека позволяет настроить поведение так, что бы при делении на ноль чисел с плавающей точкой так же выбрасывалось исключение (std::fesetexceptflag()).

Если вы хотите получить какое-то число близкое к нулю - реализуйте деление так как считаете нужным.

Память под статический массив выделяется на стеке. При выходе из области видимости стек очищается и память под массивом освобождается автоматически (не нужна операция освобождения памяти, операция есть, но о ней позаботится компилятор самостоятельно).

Память для динамического массива выделяется в динамической памяти (в куче) (new[]). Когда массив становится не нужным память должна быть освобождена (delete[]), иначе произойдет утечка памяти.

В связи с вышеизложенными принципиальными отличиями, есть несколько следствий:
1. Имя статического массива это не указатель. Это можно понять например сравнив, что возвращает sizeoff() для статического массива и для динамического. Хотя в некоторых ситуациях компилятор ведет себя так, как будто имя статического массива это указатель, например: можно передать имя статического массива в функцию, принимающую указатель.
2. У динамического массива нет имени. Операция new[] возвращает указатель. Имя есть у указателя.
3. Внимание! Оба варианта массивов имеют фиксированный размер. Изменять его нельзя!
То что в std::vector вы можете укладывать кучу элементов постепенно, не указывая нигде предварительного размера является следствием того, что std::vector скрывает от вас всю работу, которую он при этом делает. При добавлении нового элемента, для которого нет места, он выделяет память для нового массива большего размера, копирует старый массив в новый, удаляет старый массив, добавляет новый элемент. Если идет интенсивная работа с push_back(), то это может ОООЧЕНЬ дорого стоить. std::vector - это удобно, но необходимо всегда помнить, за счет чего достигается это удобство. std::vector - это не динамический массив - это обертка над ним для более удобной работы с динамическим массивом.

В языке Си (C99) есть такая штука как Variable Length Array (VLA) - это статический массив с изменяемым размером. Т.е. вы можете, например, в функции объявить int arr[N], где N будет передаваться в функцию как параметр.
В стандарте С++ VLA нет! Но, например, тот же gcc с опциями по умолчанию разрешает его использования в С++ проектах. С опциями, заставляющими gcc более жестко следовать стандарту, он может запрещать использовать VLA в С++ проектах. Но не рассчитывайте, что все компиляторы будут так делать. Например микрософтовский компилятор в принципе не умеет в VLA (хотя я уже пару лет не проверял это).
VLA может показаться классной штукой.
Но, например, в ядре Линукс в свое время проводили целую компанию по выпиливанию VLA из исходников. Торвальдс высказывался негативно про VLA. Все это при желании можно нагуглить.
Стоит помнить, что размер стека ограничен, а VLA то же выделяется на стеке. Кроме того выделение памяти для обычного статического массива это просто увеличение счетчика стека на константу (и все, одна операция сложения регистра с константой, а компилятор одной операцией выделяет память для всех переменных в текущей области видимости). С VLA все сложнее с выделением и удалением. Так же sizeof() для обычного статического массива это операция времени компиляции (при выполнении будет уже заранее известная константа), для VLA - это полноценный вызов функции.

MSDN говорит, что объявление Sleep() находится в файле synchapi.h. Так что можете подключать этот файл, а не глобальный Windows.h.
Так же можно просто выдернуть объявление этой функции из synchapi.h и вставить его в свой код:
void Sleep(DWORD dwMilliseconds);
После этого можно использовать функцию. Главное не забудьте подключить виндовые библиотеки при сборке. Эта функция находится в Kernel32.lib.

Используйте динамическую (а не статическую) линковку со стандартной библиотекой, возможно это уменьшит размер исполняемого файла. Но в этом случае клиенту придется тащить дополнительные библиотеки в виде отдельных файлов *.dll или в случае MSVC устанавливать runtime правильной версии.

Почему вы в функции с переменным количеством аргументов не используете стандартный механизм для работы с аргументами в подобных функциях (#include <cstdarg>)?

Поставьте отладочный вывод в цикл, где выведите значение count, а заодно и *ptr и comp. То же самое можно быстро посмотреть в отладчике затратив минуты 3 на все. Выводите значение floatов с большим количество знаков после запятой (10-15).
Вы будете удивлены тому, что во float 3.0 это не обязательно равно 3, ну и т.д. То же самое относится к любым типам с плавающей точкой.
Передавайте первым аргументом uint32_t, вторым и следующим float. Тогда все будет нормально. Код, конечно, придется немного переделать.

или я что то не так понял

Именно.
Вы выбрали асинихронный инструмент, не понимая как он работает.
ioc.run() - запускает цикл обработки асинхроных событий (event loop). Когда он завершается, то вы не сможете уже что-либо получать/передавать.
Ваша задача добавить нужный вам код в обработчики событий (функции on_xxx()). Как это правильно делать смотрите документацию по библиотеке и возможно другие примеры использования.

Я никогда не использовал boost.beast и WebSocket, но некоторый опыт асинхронного программирования есть, а принципы асинхронного программирования в любых библиотеках одни и те же.

u8 говорит о том, что строка в кавычках будет в кодировке UTF8: https://en.cppreference.com/w/cpp/language/string_...
sv - преобразует строку в string_view: https://en.cppreference.com/w/cpp/string/basic_str...
А нужно оно или нет - решать вам, в зависимости от контекста.

Используют ту версию, которая принята в проекте. Обычно, в проекте уже приняты определенные правила, в т.ч. и по используемому компилятору, версии языка и т.п. Ты просто принимаешь эти правила и работаешь в проекте (или не принимаешь и не работаешь).
Сейчас все используют минимум C++14. C++14 - это небольшой апгрейд над C++11, все значимые изменения были в C++11, так что литература по С++11 вполне подходит.
Самые "продвинутые" используют С++17 и может быть кто-то уже и С++20.
Хватает и старых проектов, где большая кодовая база, написана на старых стандартах языка до С++11.

На самом деле основы языка изменяются мало. Вся ООП обвязка вполне актуальна со времен С++03, кое что добавили, но и старое то же работает.

У функции объявленной как:
void func(...);
нет возвращаемого значения.
То что функция в данном примере это метод класса значения не имеет.

Сконвертируйте строку в число с помощью strtod() (или любой функции из этой серии) и проанализируйте возвращаемое значение и значение второго параметра. По этой информации можно сделать любые нужные выводы.

Еще есть isdigit() - но она проверяет символ только на цифры, а число может быть разным - например начинаться со знака или если дробное, то в нем будет разделитель дробной части, который может быть первым. Но в простых случаях ее может быть достаточно.

Функцию count реализуйте макросом:

#define count(arr)     (sizeof(arr) / sizeof(arr[0])

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