tmux не позволяет клавишам Ctrl vim [дублировать]

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

Однако, если вы

• Итак, сначала GCC: использование
  • Итак, сначала GCC: использование Nuwen MinGW 15 GCC 7.1 вы получите:

    #include
    int main(int argc, char ** argv)
    {
    int i = 0;
    i = i++ + ++i;
    printf("%d\n", i); // 2
    
    i = 1;
    i = (i++);
    printf("%d\n", i); //1
    
    volatile int u = 0;
    u = u++ + ++u;
    printf("%d\n", u); // 2
    
    u = 1;
    u = (u++);
    printf("%d\n", u); //1
    
    register int v = 0;
    v = v++ + ++v;
    printf("%d\n", v); //2
    

    }

  Как работает GCC? он оценивает подвыражения в порядке слева направо для правой стороны (RHS), затем присваивает значение левой стороне (LHS). Именно так ведут себя Java и C # и определяют их стандарты. (Да, эквивалентное программное обеспечение на Java и C # определило поведение). Он оценивает каждое вспомогательное выражение один за другим в Заявлении RHS в порядке слева направо; для каждого подвыражения: сначала выполняется оценка ++ c (pre-increment), затем значение c используется для операции, затем приращение post c ++).

  в соответствии с GCC C ++: Операторы

  В GCC C ++ приоритет операторов контролирует порядок, в котором отдельные операторы оцениваются

  эквивалентный код в определенном поведении C ++, как понимает GCC:

  #include
  int main(int argc, char ** argv)
  {
      int i = 0;
      //i = i++ + ++i;
      int r;
      r=i;
      i++;
      ++i;
      r+=i;
      i=r;
      printf("%d\n", i); // 2
  
      i = 1;
      //i = (i++);
      r=i;
      i++;
      i=r;
      printf("%d\n", i); // 1
  
      volatile int u = 0;
      //u = u++ + ++u;
      r=u;
      u++;
      ++u;
      r+=u;
      u=r;
      printf("%d\n", u); // 2
  
      u = 1;
      //u = (u++);
      r=u;
      u++;
      u=r;
      printf("%d\n", u); // 1
  
      register int v = 0;
      //v = v++ + ++v;
      r=v;
      v++;
      ++v;
      r+=v;
      v=r;
      printf("%d\n", v); //2
  }
  

  Затем переходим к Visual Studio . Visual Studio 2015 вы получаете:

  #include
  int main(int argc, char ** argv)
  {
      int i = 0;
      i = i++ + ++i;
      printf("%d\n", i); // 3
  
      i = 1;
      i = (i++);
      printf("%d\n", i); // 2 
  
      volatile int u = 0;
      u = u++ + ++u;
      printf("%d\n", u); // 3
  
      u = 1;
      u = (u++);
      printf("%d\n", u); // 2 
  
      register int v = 0;
      v = v++ + ++v;
      printf("%d\n", v); // 3 
  }
  

  Как работает визуальная студия, она использует другой подход, оценивает все выражения предварительного приращения в первом проходе, затем использует значения переменных в операциях во втором проходе, назначать из RHS на LHS в третьем проходе, затем, наконец, пропустить, он оценивает все выражения после инкремента за один проход.

  Таким образом, эквивалент в определенном поведении C ++, как Visual C ++, понимает:

  #include
  int main(int argc, char ** argv)
  {
      int r;
      int i = 0;
      //i = i++ + ++i;
      ++i;
      r = i + i;
      i = r;
      i++;
      printf("%d\n", i); // 3
  
      i = 1;
      //i = (i++);
      r = i;
      i = r;
      i++;
      printf("%d\n", i); // 2 
  
      volatile int u = 0;
      //u = u++ + ++u;
      ++u;
      r = u + u;
      u = r;
      u++;
      printf("%d\n", u); // 3
  
      u = 1;
      //u = (u++);
      r = u;
      u = r;
      u++;
      printf("%d\n", u); // 2 
  
      register int v = 0;
      //v = v++ + ++v;
      ++v;
      r = v + v;
      v = r;
      v++;
      printf("%d\n", v); // 3 
  }
  

  как документация Visual Studio в Приоритет и порядок оценки :

  Если несколько операторов отображаются вместе, они имеют одинаковый приоритет и оцениваются в соответствии со своей ассоциативностью. Операторы в таблице описаны в разделах, начинающихся с операторов Postfix.