Mercury13

Тут есть два модификатора.

1. extern "C" — говорит, что функцию НЕ надо «козявить» на манер Си++, кодируя в имени её параметры наподобие h(int) → _Z1hi. Используется для доступа из Си++ к функциям, которые скомпилированы другим компилятором (Паскалем, Си…), а также для всяких там функций, которым надо дать фиксированное имя — например, функций DLL.

2. __declspec(dllimport). Это нужно для доступа к функциям DLL: линкер будет брать функции прямо из DLL, без создания *.lib или *.a (как минимум MinGW так работает). Языки, сильно привязанные к определённой ОС (например, Delphi) могут создавать свои ключевые слова для доступа, например, к DLL или COM.

procedure DoSomething(x : integer); cdecl;  external 'something.dll';

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

void* используется как указатель на сырые байтовые данные, не имеющие конкретного типа.
Обычно это используется…
1. В чтении-записи в файлы и на устройства, когда мы можем писать туда абсолютно любые типы.
2. В «многоликих» функциях, которые могут принимать данные разных типов (malloc/calloc, часть функций WinAPI и ODBC).
3. Как дескриптор — указатель, который запрещается разыменовывать. В Си для этого также часто используют указатель на недоопределённый тип, в Паскале с другими правилами эквивалентности типов — на пустой record. Но только пока не появится очередная многоликая функция вроде CloseHandle.
4. Для обеспечения т.н. замыкания — передачи callback’у контекста, откуда была вызвана функция, вызвавшая callback.

BOOL WINAPI EnumWindows(
  _In_ WNDENUMPROC lpEnumFunc,
  _In_ LPARAM      lParam
);

BOOL CALLBACK EnumWindowsProc(
  _In_ HWND   hwnd,
  _In_ LPARAM lParam
);

Вот этот LPARAM, который обычно определяется как какой-то указатель, и есть замыкание. Функция EnumWindows обещает передать его в функцию lpEnumFunc без изменений.
(В Си++ для этого также используют виртуальные интерфейсы, но такой метод, сами понимаете, языкозависим и не годится для межъязыкового API.)

Что происходит на стороне функции? Одно из двух (считаем, функция написана на ЯВУ).
1. Либо вызывается некая функция устройства, которая говорит: «записать 100 байт», и дальше уже работает железо.
2. Либо мы преобразуем void* в нужный нам тип и работаем с ним.

Типы указателям дают по трём причинам.
1. Вы забыли про операцию «разыменовать указатель». Чтобы его разыменовать, он должен иметь тип!
2. Чтобы не ошибаться и не переприсвоить несовместимые указатели.
3. Для полиморфизма — в Си++, давая delete x, мы даже можем не хранить, сколько байтов в блоке, поскольку мы знаем длину типа. (Есть ещё и виртуальные классы, но это другой вопрос.)

На x86 оба они — макроопределения для нестандартного соглашения вызова __stdcall.
На ARM они ничего не делают.

Соглашение вызова — это…
• как на уровне регистров мы вызываем функцию;
• кто подчищает стек за вызывающим;
• кто отвечает за восстановление регистров, если они менялись (или есть риск, что они менялись).

stdcall — вызов через стек, справа налево, за очистку стека отвечает функция, результат в eax (rax), функция отвечает за восстановление сегментных регистров, esp и ebp, программа за остальные.

На ARM используется соглашение cdecl. То же самое, но за очистку стека отвечает программа (что там на ARM с регистрами, я не в курсе).

Это так называемая асимптотическая сложность — сложность при n→∞.

Что никто не упомянул — так называемые символы Ландау.
a(n) = o(b(n)), (читается «о малое», «меньшего порядка чем»), если lim{n→∞}a/b = 0
a(n) = O(b(n)), (читается «о большое», «не большего порядка чем»), если a/b ограничено сверху (для дискретного n этого хватит, для непрерывного надо добавить «для какого-то n>N»).

Два символа Дональда Кнута дополняют символы Ландау.
a(n) = Ω(b(n)), если b(n) = O(a(n)). «Не меньшего порядка чем»
a(n) = Θ(b(n)), если a(n) = O(b(n)) и b(n) = O(a(n)). «Такого же порядка».

Ну а дальше идут простые пределы.
• axⁿ + bxⁿ⁻¹ + … = O(cx^k + dx^k−1 + …), если n ≤ k;
• те же два многочлена o(·), если n < k.
• те же два многочлена Θ(·), если n = k.
Константа не важна: во-первых, при n→∞ меньшая сложность рано или поздно перевесит меньшую константу. Во-вторых, особенности реализации того или иного алгоритма на том или ином компиляторе/железе (больше/меньше команд, лучше/хуже с кэшем) эту константу могут варьировать в широких пределах;

А значит, многочлен n(n−1)/2 = n²/2 − n/2 = Θ(n²).

Да, и ещё: вы спутали асимптотический порядок самогó многочлена и асимптотическую сложность его вычисления. Первое, как я уже сказал, n². Сложность вычисления в лоб — n+const = O(n). А «не в лоб» — «за константу» , O(1).

Абстрактные классы делят на интерфейсы и частично реализованные. Грань между ними такова:
• Интерфейс не имеет данных.
• У интерфейса все неабстрактные виртуальные методы представляют собой или эталонное поведение, или самую частую реализацию. В обоих случаях, если что, их надо не расширять, а переписывать с нуля.

Так вот, для интерфейсов таких конструкторов, разумеется, не нужно.

Например, между абстрактным потоком и файлом Win32 может быть такая иерархия: Stream → HandleStream → File. Stream — интерфейс, даже если там есть что-то типа

// virtual
unsigned long long Stream::remainder() const { return size() - pos(); }

HandleStream содержит уже данные (дескриптор Win32), и это уже частично реализованный класс, который крутится вокруг этого дескриптора: в деструкторе вызов CloseHandle, конструктор может принимать дескриптор, полученный каким-то «левым» образом.

HandleStream::HandleStream(HANDLE aHandle) : fHandle(aHandle) {}
HandleStream::~HandleStream() { close(); }

void HandleStream::close()
{
  if (Handle != INVALID_HANDLE)  { // не помню, как там эта константа в Win32
    CloseHandle(fHandle);
    fHandle = INVALID_HANDLE;
  }
}

Вот в таких полуреализованных классах, разумеется, конструктор может инициализировать те данные, которые там есть.

Коэффициент детерминации тут ни к чему.
Чтобы получить коэффициент детерминации, нужно много статистики и зависимость y(x).
Этот товарищ, насколько я понял, использовал как модель единичный лаг. Взял много команд и футбольных сезонов, модель — сколько очков получено в прошлый год, зависимая переменная — сколько очков в этот год.

R² — это так называемый коэффициент детерминации. Как он работает?
Изначальная дисперсия переменной y будет D1.
Наладили модель — дисперсия модели D2, которая, надо полагать, меньше D1 (особенно если вся выборка обучающая, без экзаменационной; здравствуй, переобучение!).
Тогда R² = 1 − D2/D1 = (D1 − D2) / D1.

Дисперсия, как известно, измеряется в квадратных попугаях. И, кроме того, для независимых величин D(x+y) = Dx+Dy. Таким образом, √(D1 − D2) ~ √R² — это тот разброс, который мы объяснили моделью.

Но он, по-видимому, натягивает сову на глобус. В его модели объяснённый разброс — 0,780 (ещё и округлять не умеет), необъяснённый — √D2 ~ √(1 − R²) = 0,626, и в зависимости от того, что хочешь доказать, можно манипулировать статистикой в ту или иную сторону. Вот так я могу сказать, что с такими разбросами всего на 0,780 / (0,780+0,626) = 55% умение, и на 45% — удача. Так что нет, коэффициент детерминации, и точка. Повторяю, для независимых величин один разброс частично компенсируется другим, и D(x+y) = Dx+Dy. В квадратных попугаях.

Первое. То есть в какую сторону смотрит объектив и как он повёрнут вокруг оси.
Второе (указатель на центр камеры) — это вектор c.

Перед нами структура данных под названием «односвязный список». У каждого элемента ссылка на следующий, у всей очереди ссылка на голову (front) и иногда на хвост (rear).

Для чего нужна проверка на заполненность — непонятно, ведь ёмкость списка не ограничена и единственный способ убедиться, что очередь полна — завести память под новый элемент. Выпадает авария std::bad_alloc — значит, памяти не хватило. Если только для каких-то прикладных нужд: так, в StarCraft очередь на строительство пять юнитов, и точка. (Есть другой тип очереди, т.н. циклическая очередь — вон там ограничено.)

Как работает enqueue: создаём новый элемент, следующий за ним — nullptr. Если очередь пуста, направляем на него front и rear. В противном случае пристраиваем его за тем, на который «смотрит» rear, и перенаправляем rear. Таким образом, «направляем rear» можно вынести за скобки, а остальные два исполнить в зависимости от пустоты очереди.

В крайне-крайне редких случаях, когда вы пишете редактируемый пользовательский интерфейс. Например, в ERP.
Разумеется, QUiLiader под капотом есть всегда, но среднему программисту он ни к чему.

Ваш код коряв (и пишет за пределы буфера, если в потоке действительно окажется 2048 байт) но нуль-терминированные строки отрабатывает правильно.

TCP работает сплошным потоком, и если вы послали в сокет нечто ещё, кроме «123123», он считает весь поток до 2048 байт и, разумеется, строки не совпадут: с одной строны «123123», с другой, например, «123123qwe».

Вам надо своими силами разбивать TCP-поток на сообщения — например, тем самым нулевым символом, CR или двумя/четырьмя байтами длины пакета.