Что такое беззнаковый символ?

Это зависит от реализации, поскольку стандарт C НЕ определяет подписи char. В зависимости от платформы char может быть signed или unsigned, поэтому вам нужно явно запросить signed char или unsigned char, если ваша реализация зависит от этого. Просто используйте char, если вы собираетесь представлять символы из строк, так как это будет соответствовать тому, что ваша платформа помещает в строку.

Разница между signed char и unsigned char вполне ожидаема. На большинстве платформ signed char будет 8-битным числом с дополнением до двух в диапазоне от -128 до 127, а unsigned char будет 8-битным целым числом без знака (от 0 до 255). Обратите внимание, что стандарт НЕ требует, чтобы типы char имели 8 бит, только sizeof(char) возвращает 1. Вы можете получить количество бит в символе с CHAR_BIT в limits.h. Однако сегодня есть несколько платформ, на которых это будет что-то другое, кроме 8.

Есть хорошее резюме этой проблемы здесь.

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

signed char имеет диапазон от -128 до 127; unsigned char имеет диапазон от 0 до 255.

char будет эквивалентен символу со знаком или без знака, в зависимости от компилятора, но это отдельный тип.

Если вы используете строки в стиле C, просто используйте char. Если вам нужно использовать символы для арифметики (довольно редко), укажите явно подписанный или неподписанный для переносимости.

Если вы хотите использовать символ как небольшое целое число, самый безопасный способ сделать это - использовать типы int8_t и uint8_t.

Некоторые поисковые запросы нашли это, где люди обсуждали это.

Беззнаковый символ - это, по сути, один байт. Таким образом, вы могли бы использовать это, если вам нужен один байт данных (например, возможно, вы хотите использовать его для включения и выключения флагов, которые будут передаваться функции, как это часто делается в Windows API).

unsigned char - это байтовое значение без знака (от 0 до 255). Вы можете думать о char как о «персонаже», но на самом деле это числовое значение. Обычный char подписан, поэтому у вас есть 128 значений, и эти значения сопоставляются с символами с использованием кодировки ASCII. Но в любом случае то, что вы храните в памяти, является байтовым значением.

Что касается прямых значений, обычный символ используется, когда известно, что значения находятся между CHAR_MIN и CHAR_MAX, в то время как беззнаковый символ обеспечивает удвоение диапазона на положительном конце. Например, если CHAR_BIT равен 8, диапазон обычного char гарантированно будет только [0, 127] (потому что он может быть подписанным или беззнаковым), тогда как unsigned char будет [0, 255], а signed char будет [-127, 127] ].

Что касается того, для чего он используется, стандарты позволяют напрямую преобразовывать объекты POD (простые старые данные) в массив беззнаковых символов. Это позволяет вам исследовать представление и битовые шаблоны объекта. Такой же гарантии безопасного выбора типа не существует для char или signed char.

Если вам нравится использовать различные типы определенной длины и подписи, вам, вероятно, лучше использовать uint8_t, int8_t, uint16_t и т. д. Просто потому, что они делают именно то, что говорят.

Беззнаковый символ использует бит, зарезервированный для знака обычного символа, в качестве другого числа. Это изменяет диапазон на [0 - 255], а не на [-128 - 127].

Обычно символы без знака используются, когда вам не нужен знак. Это будет иметь значение при выполнении таких вещей, как сдвиг бит (сдвиг расширяет знак) и других вещей при работе с char как байтом, а не с использованием его как числа.

unsigned char - это сердце всех хитростей. Почти во ВСЕХ компиляторах для ВСЕЙ платформы unsigned char - это просто байт и целое число без знака (обычно) из 8 бит, которое можно рассматривать как небольшое целое число или как набор битов.

В зависимости, как сказал кто-то другой, стандарт не определяет знак символа. Итак, у вас есть 3 разных типа char: char, signed char, unsigned char.

Например, использование беззнаковый символ:

unsigned char часто используется в компьютерной графике, которая очень часто (хотя и не всегда) назначает один байт каждому компоненту цвета. Обычно цвет RGB (или RGBA) представлен 24 (или 32) битами, каждый из которых соответствует unsigned char. Поскольку значения unsigned char попадают в диапазон [0,255], значения обычно интерпретируются как:

• 0 означает полное отсутствие данного цветового компонента.
• 255 означает 100% данного цветового пигмента.

Таким образом, вы получите красный цвет RGB как (255,0,0) -> (100% красный, 0% зеленый, 0% синий).

Почему бы не использовать signed char? Арифметика и сдвиг битов становятся проблематичными. Как уже объяснялось, диапазон signed char существенно смещен на -128. Очень простой и наивный (в основном неиспользуемый) метод преобразования RGB в оттенки серого - это усреднение всех трех цветовых компонентов, но при отрицательных значениях цветовых компонентов возникают проблемы. Красный (255, 0, 0) усредняет до (85, 85, 85) при использовании арифметики unsigned char. Однако, если бы значения были signed chars (127, -128, -128), мы бы получили (-99, -99, -99), что было бы (29, 29, 29) в нашем пространстве unsigned char, что является неверно.

Не гарантируется, что char и unsigned char будут 8-битными типами на всех платформах - они гарантированно будут 8-битными или больше. На некоторых платформах есть 9-битные, 32-битные или 64-битные байты. Однако наиболее распространенные сегодня платформы (Windows, Mac, Linux x86 и т. д.) Имеют 8-битные байты.

В C++ существует три типа символов отчетливый:

• char
• signed char
• unsigned char

Если вы используете символьные типы для текст, используйте неквалифицированный char:

• это тип символьных литералов, таких как 'a' или '0'.
• это тип, который составляет строки C, например "abcde"

Он также работает как числовое значение, но не указано, рассматривается ли это значение как знаковое или беззнаковое. Остерегайтесь сравнения символов через неравенство - хотя, если вы ограничиваете себя ASCII (0-127), вы почти в безопасности.

Если вы используете символьные типы как числа, используйте:

• signed char, который дает по меньшей мере диапазон от -127 до 127. (Обычно от -128 до 127)
• unsigned char, который дает вам по меньшей мере в диапазоне от 0 до 255.

«По крайней мере», потому что стандарт C++ дает только минимальный диапазон значений, который должен охватывать каждый числовой тип. sizeof (char) должен быть 1 (то есть один байт), но теоретически байт может быть, например, 32-битным. sizeof по-прежнему будет указывать свой размер как 1. - означает, что у вас мог есть sizeof (char) == sizeof (long) == 1.

Поскольку я чувствую, что это действительно необходимо, я просто хочу изложить некоторые правила C и C++ (в этом отношении они одинаковы). Во-первых, все битыunsigned char участвует в определении значения, если какой-либо объект типа unsigned char. Во-вторых, unsigned char явно указан без знака.

Теперь я обсуждал с кем-то, что происходит, когда вы конвертируете значение -1 типа int в unsigned char. Он отказался от идеи, что все биты результирующего unsigned char будут установлены в 1, потому что он беспокоился о представлении знаков. Но он не обязан. Из этого правила сразу следует, что преобразование делает то, что задумано:

If the new type is unsigned, the value is converted by repeatedly adding or subtracting one more than the maximum value that can be represented in the new type until the value is in the range of the new type. (6.3.1.3p2 in a C99 draft)

Это математическое описание. C++ описывает это в терминах исчисления по модулю, которое подчиняется тому же правилу. В любом случае, нет гарантирует, что все биты целого числа -1 равны единице до преобразования. Итак, что у нас есть, чтобы мы могли утверждать, что в результирующем unsigned char все биты CHAR_BIT обращены в 1?

1. Все биты участвуют в определении его значения, то есть в объекте не встречаются биты заполнения.
2. Добавление только одного раза UCHAR_MAX+1 к -1 даст значение в диапазоне, а именно UCHAR_MAX

Собственно, хватит! Поэтому всякий раз, когда вы хотите, чтобы у unsigned char были все биты единым целым, вы должны

unsigned char c = (unsigned char)-1;

Из этого также следует, что преобразование нет просто усекает биты более высокого порядка. Удачным событием для два дополнения является то, что это просто усечение, но то же самое не обязательно верно для других представлений знаков.

unsigned char принимает только положительные значения .... например, от 0 до 255

в то время как

signed char принимает как положительные, так и отрицательные значения .... например, от -128 до +127

цитируется из книги "Занятия по программированию на c":

Квалификатор signed или unsigned может применяться к char или любому целому числу. беззнаковые числа всегда положительны или равны нулю и подчиняются законам арифметики по модулю 2 ^ n, где n - число бит в типе. Так, например, если символы равны 8 битам, переменные типа char без знака имеют значения от 0 до 255, в то время как символы со знаком имеют значения от -128 до 127 (в двух машина дополнения.) Независимо от того, подписаны ли простые символы или нет, зависит от машины, но печатные символы всегда положительны.

unsigned char принимает только положительные значения: от 0 до 255, в то время как signed char принимает положительные и отрицательные значения: от -128 до +127.

signed char и unsigned char представляют 1 байт, но имеют разные диапазоны.

   Type        |      range
-------------------------------
signed char    |  -128 to +127
unsigned char  |     0 to 255

В signed char, если мы рассматриваем char letter = 'A', 'A' представляет двоичное число 65 в ASCII/Unicode, если 65 может быть сохранено, -65 также может быть сохранено. В ASCII/Unicode нет отрицательных двоичных значений, чтобы не беспокоиться об отрицательных значениях.

Пример

#include <stdio.h>

int main()
{
    signed char char1 = 255;
    signed char char2 = -128;
    unsigned char char3 = 255;
    unsigned char char4 = -128;

    printf("Signed char(255) : %d\n",char1);
    printf("Unsigned char(255) : %d\n",char3);

    printf("\nSigned char(-128) : %d\n",char2);
    printf("Unsigned char(-128) : %d\n",char4);

    return 0;
}

Выход -:

Signed char(255) : -1
Unsigned char(255) : 255

Signed char(-128) : -128
Unsigned char(-128) : 128