Кто-нибудь встречал в своей практике sizeof(char) != 1?

Заинтересовался в связи с одним из ответов на недавний вопрос по C++ (C)

Вычисление длины строки без использования strlen()

Я не встречал, и даже не могу припомнить ни одного описания какой-нибудь систем
с размером char больше одного байта. Естественно, речь идет о C (C++), а не о Java и т.п.

Заодно, с байтом не из 8-ми бит кто-нибудь дело имел ?
    

Ответы

Ответ 1

Системы с размером char больше одного байта не только существовали, но существую
и активно используются в наши дни. Как правило, это встраиваемые системы или специализированны
процессоры, например, DSP. Вот цитата из отчета Reading and Writing Binary Files o
Targets With More Than 8-Bit Chars компании Texas Instruments, четвертого в мире производител
полупроводниковых приборов:

On theC2000 and C5000 DSP platforms, a char is 16 bits; on the C3x DSP generation
a char is 32 bits.

@avp, прокомментирую

Вот про sizeof('t') == sizeof(int) это может быть важно. 

Да, может, но чаще всего разница нивелируется знаковым расширением кода символа д
int. Рассмотрим маленький пример чтения одного символа из файла и сравнения с признако
завершения:
#include 

int main()
{
    if (getchar() == EOF)
        printf("Ох, Щи!!!");
    return 0;
}

Запустим, передав программке файл с одним символом с кодом 0xFF:
user@linux:~> echo $'\xff' > test
user@linux:~> gcc test.c
user@linux:~> ./a.out < test
user@linux:~>

Никакого вывода, и это логично - getchar() возвращает интовое значение 255, сравнивае
с -1 (EOF), не совпадают. Однако следующие два примера
if ('\xff' == EOF)
    printf("Ох, Щи!!!");

и
int c = '\xff';
if (c == EOF)
    printf("Ох, Щи!!!");

демонстрируют равенство значений, поскольку значение 'xff' расширяется до int знаков
(получится 0xffffffff = -1). С одной стороны, это источник ошибок, с другой - тако
поведение не порождает несовместимости с C++, где char строго равен одному байту и пр
сравнении с int будет расширен таким же образом.


Ответ 2

C++ Standard - 5.3.3 / 1:


  sizeof(char), sizeof(signed char) and sizeof(unsigned char) are 1.

Более интересным, кстати говоря, является тот факт, что в C sizeof('t') будет раве
не 1, а sizeof(int).


  Символьные константы (заключённые в одинарные кавычки) по умолчанию имеют: ти
int в С и тип char в C++. Поэтому в C справедливо равенство sizeof('t') == sizeof(int)
а в C++ — равенство sizeof('t') == sizeof(char).


Ответ 3

Насколько я знаю:

char - это единственный задокументированный тип с точным указанным размером. 
Остальные типы имеют относительный размер, например: 

1 == sizeof(char) <= sizeof(short) <= sizeof(int) <= sizeof(long) <= sizeof(long long)


Ответ 4

Кто-нибудь встречал в своей практике sizeof(char) != 1 ?

Дефайны творят чудеса:
#include 
#define char wchar_t
int main()
{
    printf("sizeof(char)==%d", sizeof(char));
}

Выведет sizeof(char)==2.


Ответ 5

Может быть выставлено выравнивание по границе int, что сделает верным выражение sizeof(char)==sizeof(int).


Ответ 6

Столько ответов и только один частично правильный. Нельзя же людей вводить в заблуждение
В стандарте С (6.5.3.4 The sizeof operator)


  When applied to an operand that has type char, unsigned char, or
  signed char, (or a qualified version thereof) the result is 1.


и С++ (5.3.3 Sizeof)


  sizeof(char), sizeof(signed char) and sizeof(unsigned char) are 1.


четко сказано, что тип char имеет размер ОДИН байт. Никакая система не может имет
компилятор, который поддерживает стандарт и который вернет в sizeof(char) что то другое
Иначе это нестандартный компилятор!
Теперь о "справедливом" равенстве sizeof(char) == sizeof(int). Не нужно путать значени
возвращаемое sizeof с возвращаемым типом, потому что sizeof возвращает тип int и в это
смысле да, равенство может быть. И даже такое равенство может быть 'c' != 0, потом
что 'c' будет выровнено до типа int, опять же стандарт. Но, литерал 'c' имеет тип cha
и поэтому sizeof('c') вернет единицу и, да, типа int.
Далее, язык программирования и его реализация на разных платформах это разные вещи
И если квант хранения информации не позволяет хранить один байт, то тогда, да, однобайтовы
тип будет храниться в двух и более байтах в зависимости от минимального кванта информаци
системы. Но это никакого отношения не имеет к sizeof(char).
Теперь о дурацком примере, который вводит в еще большее заблуждение. 

if (getchar() == EOF)


Естественно, что возвращаемое значение getchar() будет выровнено до int со свои
значением, т.е. до 0x000000FF и конечно это не будет равно 0xFFFFFFFF.
Следующий более интересный вариант.

if ('\xff' == EOF)


А тут мы сравнивает (char)-1 с (int)-1, почему? Да потому что произошла конвертаци
из char в int и -1 превратился снова в -1.

UPD: По итогам обсуждения

Стандарт С++ имеет понятие байт и если речь идет об операторе sizeof, то в в это
случае размер возвращается именно в байтах. И хотя в определениях диапазонов и в примера
приводятся значения требующие именно восьми бит, сама битность напрямую в стандарт
не определяется. Требуется только то, чтобы байт смог как минимум разместить все зарезервированны
в стандарте символы.

Что касается самого определения байта, то оно есть в стандарте IEC 80000 и определяетс
именно как октет, восемь бит. Любая документация прямо не указывающая размерность байт
основывается на стандарте. Но, стандарт не закон, поэтому отклонения могут быть. Наприме
дополнительные биты могут быть использованы для контроля целостности информации ил
в других служебных целях, но для пользователя все равно будет видны только восемь бит
Любое другое отклонение это скорее анахронизм.