Преобразование короткого замыкания в беззнаковое короткое и сохранение путаницы с битовой комбинацией

как мне сохранить битовый шаблон для значений i ниже нуля?

При очень распространенном кодировании с дополнительным кодом до 2 достаточно следующего.

unsigned short us = (unsigned short) some_signed_short;

День BITD с дополнением до единиц и величиной знака, этого было недостаточно, и код будет использовать union из short и unsigned short.

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

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

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

При печати short, unsigned short лучше всего использовать модификатор h printf.

//printf("short value is          : %d\n", i);
//printf("unsigned short value is : %d\n", arr[arrIndex]);
printf("short value is          : %hd\n", i);
printf("unsigned short value is : %hu\n", arr[arrIndex]);

В C, если вы вызываете вариативную функцию и передаете интегральный тип любого вида, язык автоматически продвигает ее до знакового или беззнакового int того же типа. Когда вы затем распечатываете что-то с помощью модификатора %d, в результате вы видите повышенный int.

Например, когда вы звоните

printf("short value is          : %d\n", i);

(Отрицательное) значение i повышается до signed int с тем же значением, поэтому оно распечатывается как отрицательное. Когда вы тогда позвоните

printf("unsigned short value is : %d\n", arr[arrIndex]);

(Беззнаковое) значение arr[arrIndex] повышается до unsigned int, поэтому отображается положительное значение.

Чтобы исправить это, измените свой printf так, чтобы вы указали компилятору отображать результаты конкретно как short переменные:

printf("short value is          : %hd\n", i);
printf("unsigned short value is : %hd\n", arr[arrIndex]);

Теперь вы увидите, что ценности согласуются.

Значения копируются правильно. Посмотрим на следующий код:

#include <stdio.h>

void printit(char *name, short int val)
  {
  printf("%s  %hd  %hu  0x%hX\n", name, val, val, val);
  }

int main()
  {
  short int v1 = 0x8000;
  short int v2 = 0x8064;
  short int v3 = 0x80C8;

  printit("v1", v1);
  printit("v2", v2);
  printit("v3", v3);
  }

Здесь я создал четыре коротких переменных со знаком и установил для них битовые шаблоны. Забудьте на мгновение о «положительном» и «отрицательном» - я просто вставляю небольшой шаблон в эти переменные. В подпрограмме printit эти значения печатаются как десятичное со знаком, десятичное без знака и шестнадцатеричное (чтобы убедиться, что это один и тот же битовый шаблон). Теперь посмотрим на результаты:

v1  -32768  32768  0x8000
v2  -32668  32868  0x8064
v3  -32568  32968  0x80C8

Теперь вы можете видеть, что я просто скопировал использованные вами значения (-32768, -32668 и -32568) и присвоил их переменным. Единственная разница в том, что я сначала преобразовал их в шестнадцатеричный. Тот же битовый шаблон. Те же результаты. Но, за исключением нескольких редких случаев, интерпретация знакового десятичного значения битового шаблона, где десятичное значение является отрицательным, НЕ совпадает с беззнаковой десятичной интерпретацией битового шаблона. Я предлагаю прочитать Дополнение до единицы для двоичных чисел и Дополнение до двух представление отрицательных двоичных чисел.

Данные копируются правильно, побитно, как вы хотели. Это просто печать, которая отображает его как значение со знаком, потому что arr объявлен как массив значений без знака.

%d выводит данные, переданные как ints (по стандартному определению? Не уверен), что на обычных платформах составляет 4 байта. Аргумент, переданный в printf, перед печатью обновляется до int, что, в зависимости от того, подписан ли рассматриваемый аргумент или нет, потребует расширения знака или нет.

При печати i, которое является значением со знаком, значение будет расширено знаком перед печатью. Например, если i равно -1 (который представлен как 0xFFFF в 2-байтовом значении со знаком с использованием дополнения до двух), то i будет обновлено как int значение 0xFFFFFFFF (которое также равно -1, но представлено четырьмя байтами).

Однако, если i равно -1, тогда при выполнении arr[arrIndex] = i arr[arrIndex] действительно будет установлено в 0xFFFF, и будет копироваться побитно, как вы хотели. Однако, поскольку arr[arrIndex] беззнаковый, в мире беззнакового 0xFFFF представляет 65535. Затем, когда придет время печатать arr[arrIndex], поскольку arr[arrIndex] беззнаковый, значение не будет расширено по знаку, так как это беззнаковое значение. Следовательно, 0xFFFF будет обновлен до 0x0000FFFF, что равно 65535, и напечатан как таковой.

Мы можем проверить это, заставив arr считаться подписанным перед печатью. Таким образом, arr будет обрабатываться так же, как i.

#include <stdio.h>
int main() {
    unsigned short arr[450];
    unsigned short arrIndex = 0;

    for (signed short i = -32768; i < (32767 - 100) ; i = i + 100 )
    {
        arr[arrIndex] = i;
        printf("short value is          : %d\n", i);
        printf("unsigned short value is : %d\n", ((signed short*)arr)[arrIndex]);
        arrIndex++;
    }
}

Выход:

short value is          : -32768
unsigned short value is : -32768
short value is          : -32668
unsigned short value is : -32668
short value is          : -32568
unsigned short value is : -32568
short value is          : -32468
unsigned short value is : -32468
short value is          : -32368
unsigned short value is : -32368
short value is          : -32268
unsigned short value is : -32268
short value is          : -32168
unsigned short value is : -32168

Или мы могли бы напрямую объявить arr как массив значений со знаком для достижения того же результата:

#include <stdio.h>
int main() {
    signed short arr[450];
    unsigned short arrIndex = 0;

    for (signed short i = -32768; i < (32767 - 100) ; i = i + 100 )
    {
        arr[arrIndex] = i;
        printf("short value is          : %d\n", i);
        printf("unsigned short value is : %d\n", arr[arrIndex]);
        arrIndex++;
    }
}

Пожалуйста, проверьте for пределы цикла, так как если вы переходите от -32768 к <(32767-100) скачкообразно на 100 значений, вы заполняете элементы массива 655, и вы только объявили 450.

Кроме того, чтобы напечатать значение unsigned short, вам необходимо использовать спецификатор формата %u (или эквивалентный %hu, поскольку shorts преобразуются в int для использования printf()).

Используйте этот пример:

#include <stdio.h>

int main()
{
        short i;
        for (i = -32768; i < (32767 - 100); i += 100) {
                unsigned short j = i;
                printf("Signed  : %d\n", i);
                printf("Unsigned: %u\n", j);
        }

        return 0;
}

Он будет производить:

$ a.out
Signed  : -32768
Unsigned: 32768
Signed  : -32668
Unsigned: 32868
Signed  : -32568
Unsigned: 32968
Signed  : -32468
...
Signed  : -268
Unsigned: 65268
Signed  : -168
Unsigned: 65368
Signed  : -68
Unsigned: 65468
Signed  : 32
Unsigned: 32
Signed  : 132
Unsigned: 132
...
Signed  : 32432
Unsigned: 32432
Signed  : 32532
Unsigned: 32532
Signed  : 32632
Unsigned: 32632
$ _