// ======================================================================
    typedef int BRICK;                  //!< Single mesh cell
    typedef std::pair<BRICK, BRICK> BRICK2; //!< Couple of bricks
    typedef int FACET;                  //!< A facet of the cell (each cell has 6 facets)
    typedef int JOINT;                  //!< Joint between adjacent cells
    typedef unsigned char FILLING;      //!< ID of the Cell filling
    typedef int BRDATAEX;               //!< Reference to the brick additional data
    typedef int JOINTDATAEX;            //!< Reference to the joint additional data
    typedef int FACETREF;               //!< Reference to the list of facets
    typedef float PMLStretch;
    typedef float PMLSigma;
    typedef unsigned char JUNCTYPE;     //!< Тип соединения на Joint (eJunctionFace)
    typedef int UPORT;                  //!< Индекс Micro-port'а
    typedef int UPORTVAL;               //!< Значение Micro-port
    typedef int CORNER;                 //!< Угол ячейки

    // ======================================================================
    enum
    {
        Facet_Brick = 6,                // Число граней у ячейки - для SplitFace могут быть дополнительные subfacets
        Corner_Brick = 8,               // Число углов у ячейки
        UPort_Facet = 2,                // Число микропортов у одной грани или subfacet
        UPort_Brick = 6*2,              // Число микропортов у ячейки - только для Simple, PML, Conformal - больше для SplitFace Brick
        IncFacet_Max = 4                // Макс. число инцидентных граней
                                        // с одной стороны соединения
    };

    enum { NONE = -1, DEAD = -2 };

    //! Получить первый порт, принадлежащий грани
    inline UPORT Facet2UPort1(FACET f)      { return f * 2; }
    //! Получить второй порт, принадлежащий грани
    inline UPORT Facet2UPort2(FACET f)      { return f * 2 + 1; }

V>#include <iostream>

V>int main() {
V>  std::cout << ( -1 / 1u ) << std::endl;
V>  std::cout << ( -1 < 1u ) << std::endl;
V>  return 0;
V>}
V>

Преобразование встроенных типов в операторах

Выражениям так же как и значениям в C++ приписывается некоторые типы. Например, если a и b — это переменные типа int, то выражения (a + b), (a — b), (a * b) и (a / b) тоже будут иметь тип int.

Важно всегда понимать, какой тип у выражения, которое вы написали в программе. Давайте проиллюстрируем это на следующем примере:

int a = 20;
int b = 50;
double d = a / b;  // d = 0, оба аргумента целочисленные, а значит деление целочисленное
Как исправить этот код, чтобы получить вещественное значение в переменной d?

Для этого хотя бы один из аргументов оператора деления должен иметь типа double. Этого можно добиться при помощи уже известного нам оператора приведения типов:

double d = (double)a / b;  // d = 0.4

Почему это сработало? Дело в том, что операторы для встроенных типов C++ всегда работают с одинаковыми типами аргументов. Если аргументы имеют разные типы, то происходит преобразование типов (promotion).

Правило преобразования встроенных типов в операторах

Рассмотрим выражение (a + b), где вместо '+' может стоять любой другой подходящий оператор.
Если один из аргументов имеет числовой тип с плавающей точкой, то второй аргумент приводится к этому типу (например, при сложении double и int значение типа int приводится к double).
Если оба аргумента имеют числовой тип с плавающей точкой, то выбирается наибольший из этих типов (например, при сложении double и float значение типа float приводится к double).
Если оба аргумента целочисленные, но их типы меньше int, то оба аргумента приводятся к типу int (например, при сложении двух значений типа char они оба сначала приводятся к int).
Если оба аргумента целочисленные, то аргумент с меньшим типом приводится к типу второго аргумента (например, при сложении long и int значение типа int приводится к long).
Если оба аргумента целочисленные и имеют тип одного размера, то предпочтение отдаётся беззнаковому типу (например, при сложении int и unsigned int значение типа int приводится к unsigned int).
Несколько важных следствий
Следите за тем, какие типы участвуют в выражении, от этого может зависеть его значение.
Не стоит использовать целочисленные типы меньше int в арифметических выражениях, они всё равно будут приведены к int.
Не стоит смешивать unsigned и signed типы в одном выражении, это может привести к неприятным последствиям.
Для иллюстрации последнего следствия давайте рассмотрим следующий пример:
unsigned from = 100;
unsigned to = 0;
for (int i = from; i >= to; --i) { .... }
Сколько итераций сделает этот цикл? На самом деле этот цикл — бесконечный: в условии цикла проверяется i >= to, где тип i — int, а тип to — unsigned int. Так как операторы всегда применяются к одинаковым встроенным типам, то в данном случае значение переменной i (в соответствии с правилом 5) будет преобразовано к unsigned int, а значения этого типа всегда неотрицательны, т.е. >= 0. Другими словами, когда пременная i станет равной -1, то в условии будет проверяться (unsigned)-1 >= 0, где (unsigned)-1 = UINT_MAX (UINT_MAX — максимальное значение, которое может принимать переменная типа unsigned int).

#include <iostream>
using namespace std;

int main()
{
    for(unsigned u{5+1}; u-->0; )
        cout << u << endl;

    for(unsigned u{5}; u<=5; --u)
        cout << u << endl;

    return 0;
}