jcmvbkbc

Подскажите пожалуйста, почему так

Потому что порядок перечисления библиотек важен: в списке библиотек a b c символы, которые нужны библиотеке b будут искаться только в библиотеке c, но не в a. Если между библиотеками нет циклических зависимостей (т.е. нет такого, что a определяет символ, нужный b, а b определяет символ, нужный a), то их можно упорядочить так, что линковка будет успешной (см. топологическая сортировка). Если циклические зависимости есть, или сортировать лень, можно перечислить нужные библиотеки несколько раз или взять их в группу:

g++ main.cpp -Wl,--start-group -lglfw3 -lgdi32 -lopengl32 -lglew32s -Wl,--end-group

sum_of = sum(matrix[][]);

должно стать
sum_of = sum(n, matrix);

int sum (int n, int matrix[n][n]) {
    int sum = 0;
    for (int j = 0; j < n; ++j){
        for (int i = 0; i < n; ++i){
            if (j == i){
                sum += matrix[j][i];
            }
        }
    }
    return sum;
}

Это, конечно, работает, но лучше написать так:

int sum (int n, int matrix[n][n])
{
    int sum = 0;
    for (int i = 0; i < n; ++i) {
        sum += matrix[i][i];
    }
    return sum;
}

Стоит ли сокращать код? И как?

Можно сделать так:

struct
{	
  bool btn_state;
  bool btn_flag;
  bool hold_flag;
  bool counter_flag;
  bool isHolded_f;
  bool isRelease_f;
  bool isPress_f;
  bool step_flag;
  bool oneClick_f;
  bool isOne_f;

} fl;
fl flags;
// ........ 

boolean GButton::isFlag(bool& flag) {
  if (_tickMode) GButton::tick();
  if (flag) {
    flag = false;
    return true;
  } else return false;
}

boolean GButton::isPress() {
  return isFlag(flags.isPress_f);
}
boolean GButton::isRelease() {
  return isFlag(flags.isRelease_f);
}
boolean GButton::isClick() {	
  return isFlag(flags.isOne_f);
}
boolean GButton::isHolded() {
  return isFlag(flags.isHolded_f);
}

приложение из командной строки с определенными аргументами, в ответ вернуло (другому приложению) данные, некий текст. Назовите пожалуйста технологию которая позволяет такое сделать.

popen например.

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. Но это не стандартный с++.

Нет, понял неправильно. 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.

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 << " ";
    }
  }

int pin = (ms / 120) % 10;
Как работает данный код с переменными int?

Делит ms на 120 (так что результат равен 0 в период [0..120[ мс, 1 в период [120..240[ мс. итд), а потом берёт остаток от деления результата на 10 (так, что результат меняется циклически в пределах [0..10[ ).

Как будет отличаться от работы с другим типом переменных (к примеру нецелочисленных)?

Никак. Встроенный оператор % работает только с целыми числами.

for(char* pnew_char = new_char; *pnew_char++ = *--pchar;);

Этот цикл работает неправильно, потому что выход из него происходит по воле случая, в зависимости от мусора, оказавшегося перед строкой, на которую указывает pchar.

for(; *pchar; ++length, ++pchar);

Делать так (писать цикл с пустым телом и точкой с запятой на той же строке) не стоит, потому что легко не заметить эту точку с запятой или её отсутствие.

for(char* pnew_char = new_char; *pnew_char++ = *--pchar;);

Так делать (писать тело цикла в его поле для условия выхода, равно как и писать его в последнем поле) не стоит, потому что всему своё место, а ошибку в этом цикле ты уже допустил.

if (strcmp(name1, name2) == 1)

man strcmp

The strcmp() and strncmp() functions return an integer less than,
       equal to, or greater than zero if s1 (or the first n bytes thereof)
       is found, respectively, to be less than, to match, or be greater than
       s2.

Для проверки на равенство должно быть
if (strcmp(name1.c_str(), name2.c_str()) == 0)