res2001

NtCreateFile находится в NtDLL.dll
Думаю, что можно использовать LoadLibrary/GetProcAddress для загрузки библиотеки и адреса функции.

Итераторы - это абстракция созданная для того что бы можно было один и тот же подход применять для обхода принципиально разных контейнеров.
Реализация итератора - это класс реализующий определенный интерфейс, как вы и написали. Внутри класса реализуйте как хотите, сохраняйте состояния, ссылки, счетчики в приватных членах данных класса итератора и т.д. и т.п. begin с end должны возвращать ссылку на соответствующий итератор. begin и end не входят в интерфейс итератора.
Учите матчасть.

Виртуальная память реализуется аппаратно-программным способом, т.е. без поддержки процессора не обойтись, поэтому ОС тут вовсе не "законодатели мод", а всего лишь используют подход предложенный разработчиками железа. Конечно, писатели осей могут то же поучаствовать в процессе проектирования железа и часто так и происходит, даже можно предположить, что сама виртуальная память появилась именно из-за хотелок разработчиков ОС. Этот подход принципиально одинаков что в винде что в линуксе для интеловских процов, т.к. диктуется спецификацией процессора, естественно разные реализации, но делают они одно и то же.
Поэтому смело можете читать по этому поводу литературу о том как работает линукс с виртуальной памятью (если найдете), в общих чертах винда работает так же.
Так же можно читать интеловскую документацию.
Но, на самом деле, если вы не собираетесь разрабатывать ядра ОС, достаточно понимать в общих чертах как это работает.

Вообще Рихтер хорошо пишет, попробуйте перечитать :-)

Виртуальная память не "взаимодействует с ОЗУ" - ОЗУ неотъемлемая часть виртуальной памяти.

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

А если я смотрю strlen(recvbuf) то получаю 16. Откуда берется такой хвост?

В recvbuf вы получаете не с-строку, а массив байт, применять строковые функции к массиву байт бессмысленно.
Отличие с-строки от массива в том, что строка оканчивается завершающим нулем, а в массиве байт вы должны знать длину массива. В с-строке символ 0 не может быть в теле самой строки, только в качестве терминального символа, в массиве байт 0 - такой же равноправный элемент данных, как и все остальные, может быть в любом месте массива или не быть вовсе.
Вам еще повезло, что выдает 16 байт, вместо 4, вполне могло бы сложиться так, что нулевого байта не было бы на достаточно продолжительном участке памяти, тогда был бы просто вылет из программы или какие-либо трудно диагностируемые глюки.

Разница только в том, что calloc обнуляет выделенную память перед тем, как возвратить указатель, а malloc этого не делает. Внутри calloc, наверняка вызывает malloc для выделения памяти, а потом memset для обнуления. Так что calloc это просто надстройка над malloc для удобства. Вот схематично реализация calloc:

void * calloc (size_t num, size_t size)
{
   void * mem = malloc(num * size);
  memset(mem, 0, num * size);
  return mem;
}

Сами эти функции оперируют исключительно размером выделяемой области в байтах, им все равно что вы в дальнейшем будете делать с выделенной памятью - инты туда писать или "стринги".
Ну и как бы никто не мешает вам одну и ту же область памяти сначала использовать как массив интов, а потом как массив байт. Или так например:

int a = 0x33323130;
char * c = (char*)&a;
printf("%c %c %c %c\n", c[0], c[1], c[2], c[3]);

Пример не использует malloc/calloc для выделения памяти, память выделяется в стеке просто объявлением int a. Тут я попытался показать, что содержимое памяти можно интерпретировать как угодно, главное находится в границах выделенного диапазона.
Причем языки С/С++/asm это позволяют делать, а другие - нет.
Пример предполагает, что int имеет размер 32 бита, не для всех платформ это так, но в основном - именно так.
Кстати этот пример можно использовать для определения порядка байтов платформы: если выведется "1 2 3 4" значит у вас LITTLE ENDIAN, а если "2 1 4 3" - BIG ENDIAN.

PS: free() - это Си, а delete - C++

Если вы изучаете С++, то лучше использовать классы стандартной библиотеки для массивов. В функцию передаете ссылку на класс.
В чистом Си передается просто указатель и размер в отдельном параметре (или 2 размера для двумерного массива).
Сам двумерный массив может быть представлен в двух вариантах:
1.Как массив указателей, где каждый указатель представляет собой одномерный массив. Нужно отдельно выделять память для массива указателей и для каждого одномерного подмассива и аналогично освобождать. В этом случае возможна операция индексации обоих измерений массива, при этом массив указателей и каждый подмассив могут находится в разных участках памяти.

void foo(int ** arr, int N, int M)
{
...
}
int main()
{
  int N = 10; // первое измерение массива
  int M = 20; // второе измерение массива
  int ** arr = new int * [N];
  for(int i = 0; i < M; ++i)
  {
     arr[i] = new int[M];
  }
  ...
  foo(arr, N, M);
  ...
  // Тут освобождение массива аналогично выделению в обратном порядке
}

2.Как одномерный массив размерностью N * M. В этом случае память под массив выделяется и освобождается вся оптом одним куском, но операция индексации первых размерностей не возможна. Но можно легко переходить от двумерного массива к одномерному, сразу вычислять нужный индекс или просто перемещаться по элементам массива с помощью временного указателя.

void foo(int * arr, size_t N, size_t M) 
{
  ...
}
int main()
{
  int N = 10; // первое измерение массива
  int M = 20; // второе измерение массива
  int * arr = new int * [N*M];
  int * arrcur = arr;  // временный указатель для обхода массива
  int * arrone = arr;  // вариант с переходом к одномерному массиву
  for(int i = 0; i < N; ++i)
  {
    for(int j = 0; j < M; ++j)
    {
        // Вариант с вычислением адреса текущего элемента по индексам
       *(arr + i * M + j) = rand() % 10;   // вычисление нужного индекса на месте
       // Вариант с обходом массива с помощью временного указателя
       *arrcur = rand() % 10; 
       ++arrcur;  // переход к следующему элементу
       // Вариант с переходом к одномерному массиву
      arrone[j] = rand() % 10; 
    }
    arrone += M;
  }
  ...
  foo(arr, N, M);
  ...
  delete[] arr;
}

Инициализируя вот так массив:
int ChValue [6] = {000011};
Вы получите в ChValue[0] = 9 - десятичное 9 - это восьмеричное 011. По правилам языка, целочисленные числовые константы, начинающиеся с 0 являются восьмеричными. В остальных элементах массива будут 0.
Вы хотите записать шесть значений в одну двухбайтовую переменную (хотя было бы достаточно и 1 байта).
Для этого вам нужно использовать битовые операции.
Например:

// ChValue - исходный массив значений по каждому каналу
int ChValue [6] = {0, 0, 0, 0, 1, 1};
uint16_t val = 0;
for(int i = 0; i < 6; ++i)
{
  if(ChValue[i] == 1)
     val |= 1 << i;
}
// в результате в val будет установлен в 1 бит с номером канала в котором в ChValue единица.

После этого просто запишите val в файл.

Освойте утилиту make и makefile.