Новые целочисленные типы для языка C++

Числа с фиксированной точкой на уровне железа - это обычные целые числа. Но вот удерживать в памяти и постоянно писать в комментариях, что "вот в этой переменной с такого-то разряда начинается дробная часть" - крайне неудобно.

Как уже отметили, "на уровне железа" это просто целые числа. Но компилятор должен "помнить" что вот у этого целого числа два знака после запятой, у того - три.

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

Правда, числа с фиксированной точкой не являются "обычными" целыми числами - формат хранения их отличается от обычного int. Существует два формата чисел с фиксированной точкой - packed и zoned:

Для формата zoned есть еще один "сахарок" - для положительных чисел внутреннее представление zoned совпадает со строковым - в кодовой таблице EBCDIC, используемой в данной системе, цифры 0..9 имеют коды 0xF0..0xF9 т.е. строка "21544" в памяти представлена как F2F1F5F4F4 что полностью совпадает с ее zoned представлением.

Для компилятора С есть расширение в виде макроса decimal():

/* this example demonstrates the use of the decimal type */

#include <decimal.h>

decimal(31,4) pd01 = 1234.5678d;
decimal(29,4) pd02 = 1234.5678d;

int main(void)
{
  /* The results are different in the next two statements */
  pd01 = pd01 + 1d;
  pd02 = pd02 + 1d;

  printf("pd01 = %D(31,4)\n", pd01);
  printf("pd02 = %D(29,4)\n", pd02);

  /* Warning: The decimal variable with size 31 should not be      */
  /*          used in arithmetic operation.                        */
  /*          In the above example: (31,4) + (1,0) ==> (31,3)      */
  /*                                (29,4) + (1,0) ==> (30,4)      */

  return(0);
}

В С++ определен шаблон _DecimalT<>

#include<bcd.h>

void main ()
{
  _DecimalT<4,0> d40 = __D("123");              // OK
  _DecimalT<6,0> d60 = __D(d40);                // Because no constructor
                                                // exists that can convert d40 to d60.
                                                // macro __D is needed to convert d40
                                                // into an intermediate type first.
                                                
  d60 = d40;                                    // OK. This is different from the
                                                // previous statement in which
                                                // the constructor was called.
                                                // In this case, the assignment
                                                // operator is called and the
                                                // compiler converts d40 into the
                                                // intermediate type automatically.
                                                
  _DecimalT<8,0> d80 = (_DecimalT<7,0>)1;       // OK
                                                // Type casting an int,not a decimal(n,p)
                                                
  _DecimalT<(9,0> d90;                          // OK
  
  d60 = (_DecimalT<7,0>)__D("12");              // OK
  
  d60 = (_DecimalT<4,0>)__D(d80);
  d60 = (_DecimalT<4,0>)__D(d80 + 1);           // In both cases, the resultant classes
                                                // of the expressions are _DecimalT<n,p>.
                                                // macro __D is needed to convert them
                                                // to an intermediate type first.
                                                
  d60 = (_DecimalT<4,0>)(d80 + (float)4.500);   // OK because the resultant type
                                                // is a float
}

И то и другое работают с числами с фиксированной точкой в packed формате. Для формата zoned нет типов в С/С++

Естественно, определена арифметика, преобразования типов.

Тут надо иметь ввиду что если вы определили число с фиксированной точкой длиной 5 знаков и пытаетесь присвоить ему значение из >5 знаков:

dcl-s var packed(5:0); // 5 символов, без запятой
var = 123456;          // пытаемся занести в него болше чем влезет

то получите системное исключение о переполнении.

Также (в С/С++ нет, но в других языках да) определены операции присваивания с округлением - работают там, где количество знаков после запятой у lvalue меньше чем у rvalue

dcl-s var1 packed(5:2);
dcl-s var2 packed(5:3);

var2 = 1.235;
var1 = var2;         // var1 = 1.23
eval(h) var1 = var2; // var1 = 1.24

Таким образом, если все делать по-хорошему, реализация чисел с фиксированной точкой тянет за собой достаточно много чего еще...

Удобно еще универсальные нетипизированные определения типа *loval / *hival - минимальное/максимальное значение для данного типа. Т.е.

double d = *loval;
int i = *hival;
char c = *loval;

а компилятор уже сам нужное значение подставит...

Пример использования (в другом языке):

dcl-s result packed(15: 2);
dcl-s uplimit packed(15:2) inz(*hival);
dcl-s lowlimit packed(15:2) inz(*loval);
dcl-s interRslt packed(63:2);

// что-то вычисляем, результат в interRslt и потом
if interRslt in %range(lowlimit: uplimit);
  // присвоение безопасно - переполлнения не будет
  result = interRslt;
else;
  // фиксируем ошибку выхода за пределы возможных значений
endif;

Также удобно для инициализации результатов поиска минимального/максимального значения и много где еще...

Добро пожаловать на Хабр.
Кнут при том, что понимает и алгоритмы, и архитектуру. Дополнительный код занял доминирующее положение не по чьему-то произволу, а потому, что это на практике лучший способ проецирования целых чисел на битовые строки. За подробностями - в "Исскуство программирования", или в "Hackers Delight" Уорена.

По-моему из перечисленного вами, всё кроме самых ранних PDP использует дополнительный код.