res2001

Разница только в том, что 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.

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

Ваша функция работает делает свое дело за 1 проход по массиву, второй вариант - за shift проходов - сложность O(N) и O(N*shift) соответственно. Во втором случае скорость зависит от величины сдвига, что очень плохо для такого алгоритма.

Циклический сдвиг массива "на месте" реализуется с помощью трех операций revers (операция изменения порядка элементов на противоположный):
1.весь массив делится на 2 массива в точке сдвига (условно, без выделения памяти)
2.revers первой части
3.revers второй части
4.revers всего массива
Встречал на stackoverflow реализацию на Си.
Работает за 2 полных прохода с операциями swap по массиву - O(2*N), но каждая операция тяжелее чем в ваших вариантах. Но быстродействие не зависит от величины сдвига и не требует дополнительной памяти, что может быть важно при работе с массивами большой размерности.
UPD: вспомнил, этот способ был описан в книге Бентли "Жемчужины программирования"!