jcmvbkbc

switch(1){
case 1:
    double d = 1; //ошибка
}

Почему нельзя инициализировать в case?

С этим кодом всё в порядке с точки зрения стандарта. Проблемы начнутся, если добавить меток case в switch после определения переменной d. Переход на эти метки входит в область видимости переменной d, но минует её инициализацию. Это запрещено стандартом (с++98, 6.7:3):

It is possible to transfer into a block, but not in a way that bypasses declarations
with initialization. A program that jumps from a point where a local variable with
automatic storage duration is not in scope to a point where it is in scope is ill-formed
unless the variable has POD type (3.9) and is declared without an initializer.

Подскажите, а можно ли по такому же принципу преобразовать char массив в int?

unsigned char a[4] = {...};
int b = ...;
memcpy(a, &b, sizeof(a)); // -- int в char
memcpy(&b, a, sizeof(a)); // -- char в int

Как объявить их так, чтобы избежать подобных ошибок?

Очень странная конструкция в коде:
- если это такой уж univeralTool, то зачем он завязывается на поле какого-то конкретного объекта какого-то класса?
- если уж надо завязаться на поле объекта, то почему эта функция -- не член этого класса?
- если надо обработать какое-то значение, то почему не передать это значение как аргумент функции?

Ну и если и ни то и ни сё, и действительно надо как написано в коде -- то раздели всё на части и используй объявления или упорядочи определения функций как следует, например так:

class someClass {
public:
  void someClassTool();
  int variableInClass = 5;
};

Someclass someclass;

void someUniversalTool()
{
  int variable1 = someClass.variableInClass ;
  //some additional code
}

void SomeClass::someClassTool()
{
   someUniversalTool();
   //some additional code
}

Потому что С++. gcc это принимает (без ключа -pedantic) просто потому что это совместимо с с99. Но это не стандартный с++.

Почему так, не подскажете?

Потому что && разбивает команду следующим образом:

( screen -dmS unpack unzip -o arhiv.zip ) && ( rm arhiv.zip )

т.е. "запустить screen и удалить файл". Чтобы удалить файл внутри screen надо написать

screen -dmS unpack bash -c 'unzip -o arhiv.zip && rm arhiv.zip'

Нет, понял неправильно. int[2][2] != int **.
Но расположение элементов нарисовал правильное.
Идея в том, что двумерный массив -- это массив массивов. Т.е. int [2][2] == int ([2])[2].
Указатель на указатель -- совсем другая песня.

int i[2][2] = {{1, 2}, {3, 4}};
int (*ii)[2] = i;
ii[0][0];

typedef int (*SIG_TYP)(int); 
typedef void (SIG_ARG_TYP)(int);
SIG_TYP signal1(int, SIG_ARG_TYP){};

как вторую конструкцию понять? это указатель?

Нет, этот тип -- это тип функции (а не указателя на функцию).
Т.е. можно написать так:
SIG_ARG_TYP foo;
и это будет объявлением функции foo.

Почему сменяется группа при изменении содержимого файла?

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

int k = n / 2;
  int l = c / 2;
  for (int i = 0; i <= k; i++)
  {
    for (int j = 0; j <= l; j++)
    {
      int temp = a[i][j];
      a[i][j] = a[i + k][j + l];
      a[i + k][j + l] = temp;
      cout << temp << " ";
    }
  }

должно стать

int k = (n + 1) / 2;
  int l = (c + 1) / 2;
  for (int i = 0; i < n / 2; i++)
  {
    for (int j = 0; j < c / 2; j++)
    {
      int temp = a[i][j];
      a[i][j] = a[i + k][j + l];
      a[i + k][j + l] = temp;
      cout << temp << " ";
    }
  }

Сначала идёт команда 7A - погасить лампочку. Команда загружает в регистр R0 число 2. Почему?

Поскольку у тебя P = 0, то R(0) используется как program counter. Инструкция 7А должна его увеличить на 1, т.е. после неё в R(0) должно быть 1.

Далее идёт команда F8 Описание этой команды M(R(P)) → D; R(P) + 1 → R(P)
Команда F8 загружает в регистр F8 число 3, хотя команда, судя по описанию, должна прибавлять к регистру R0 число 1 и сохранять результат в R0, значит в R0 должно оказаться число 1.

Нет, не так. Сначала команда загружается в регистры I и N, а R(0) увеличивается на 1. После этого достаётся байт из памяти по адресу R(0) и помещается в D, а R(0) увеличивается ещё на 1.

Дизассемблированная программа:

0: 7A -- reset Q (Q = 0)
1: F8 -- ldi 10 (D = 10)
2: 10
3: B1 -- phi 1 (R(1).1 = D, т.е. R(1) = 1000)
4: 21 -- dec 1 (R(1) = R(1) - 1, т.е. R(1) = fff)
5: 91 -- ghi 1 (D = R(1).1, т.е. D = f)
6: 3A -- bnz 4 (переход к адресу 4, пока D != 0)
7: 04
8: 31 -- bq 0 (переход к адресу 0 если Q == 1)
9: 00
a: 7B -- set Q (Q = 1)
b: 30 -- br 1 (переход к адресу 1)
с: 01
d: 00 -- idle (никогда не попадаем сюда).

В середине просто цикл задержки на счётчике.