А что, на 64-х битной архитектуре int остался 32-х битным?

Где правда каждый решает для себя сам, брат.

google LP64, LLP64, ILP64

Очевидно, что да. лонги, шорты и указатели, как указано в статье, могут меняться в зависимости от архитектуры и ОС, а char, int и double везде одной и той же длины. Просто потому, что оперативка так устроена и по скорости 1 байт читается медленнее, чем 4 (размер ячейки DDR-ов равен 4 байтам). NAND-память вроде тоже по 4 байта группируется.

А вообще, используй stdint.h

char, int и double везде одной и той же длины

Как минимум в DOS было sizeof(int) == 2

char, int и double везде одной и той же длины

Вот прямо везде-везде? В популярных DSP char, например, 16-битный.
Ъ: https://e2e.ti.com/support/dsp/tms320c6000_high_performance_dsps/f/115/t/312213

а char, int и double везде одной и той же длины

Я коротко работал на какой-то из PDP-платформ, где char был 16 бит. И, конечно, многие ещё застали DOS, где int был 16 бит (как и short), а long — 32 бита. На каких-то из TI sizeof(int)==sizeof(char)==sizeof(double)=1.

ЕМНИП, есть только одно гарантированное правило:
sozeof(char) <= sizeof(short) <= sizeof(int) <= sizeof(long). Всё остальное зависит от конкретной архитектуры.

Просто потому, что оперативка так устроена и по скорости 1 байт читается медленнее, чем 4

x86 — не единственная архитектура :)

n1256(c99) пункт 5.2.4.2.1 задает диапазон вмещаемых значений И допускает его расширение по магнитуте(implementation defined). Для int это -32767:32768

Вот и я об этом: ещё в tms320c5000. Разве что легко перепутать длину sizeof(char) == 1, которая и в них равна строго 1-му байту, с размером самого байта в 16 бит.

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

1<=sozeof(char) <= sizeof(short) <= sizeof(int) <= sizeof(long)<= sizeof(long long)
Я помню это неравенство, много где читал только никак не могу в стандарте его найти(даже словесной описание)

А может это glibc виноват?

$ arch
x86_64
$ getconf WORD_BIT
32

1<=sozeof(char)

Ну, это само собой, sizeof(type) не бывает нулевым :)

только никак не могу в стандарте его найти

Х.з., я даже не искал. Собственно, я, имея лет 7 активной практики программирования на Си/Си++ стандартов в глаза не видел :) Их тогда тупо было в продаже не найти, а интернета не было... Но вот на не-x86 размерах типов поплясать довелось. Но никогда не удивляло, так как x86 была уже ~3-я или 4-я моя платформа и организация данных на всех была разная.

Ээээм. А что не так? Ты хочешь чтобы дефолтный int был 64 битным?

Специально для таких как ты придумали long int. А вообще, классические типы надо знать где и в каких случаях применять. Когда нужна точная ширина, что мешает использовать stdint.h? Религия?

1<=sozeof(char)

Ну, это само собой, sizeof(type) не бывает нулевым :)

А разве бывает sizeof(char) > 1? Или в C++ и C это различается?

Ибо в TC++PL Страуструп писал, что sizeof(char) == 1 на любой платформе, но это самое «1» не обязательно восемь бит, а задано каким-то дефайном.

Как минимум на Alpha (под Ultrix) int был 64 бита.

А разве бывает sizeof(char) > 1?

Теоритически — да. Например, когда sizeof возвращает размер не в char'ах, а в байтах, но char больше байта (но навскидку такую платформу не назову, хотя почти уверен, что слышал когда-то).

Или в C++ и C это различается?

Вот тут не могу сказать. Я Си++ осваивал, когда концептуально он от Си, в базовых принципах, не отличался. В моё время даже NULL в Си++, как и в Си, далеко не всегда был равен 0 :) Кажется, это в стандарт ввели уже в самом конце 1990-х, а я тогда ушёл на Perl.

Если честно, не понимаю зачем сделали в языке Си одинаковые типы разной размерности. Если переменной надо хранить значения больше 64К то программист выберет 32-битную переменную в любом случае. А если больше 4G то выберет 64-битную.

Что и как это поможет оптимизировать на 64-битной платформе, где какой-то тип будет 64 бита вместо 32? Ну пусть они лежат с выравниванием 8 байт если так быстрее доступ.

Я видел на одном DSP char вообще был 32 бита - и никто не умер. А мог бы он быть 8 бит но лежать через каждые 4 байта.

От такой заботы только куча гемора.

А разве бывает sizeof(char) > 1?

Нет, он по определению = 1. А вот что именно являет собой 1, это уже зависит от реализации.

Теоритически — да

Нет, сишный стандарт четко определяет, что char = 1.

Нет, сишный стандарт четко определяет, что char = 1

c99. Но сам Си гораздо старше :)

Ну и я о том же.

Нашёл о чём говорил:

Sizes of C++ objects are expressed in terms of multiples of the size of a char, so by definition the size of a char is 1. The size of an object or type can be obtained using the sizeof operator (§10.3). This is what is guaranteed about sizes of fundamental types:
•1 ≡ sizeof(char) ≤ sizeof(short) ≤ sizeof(int) ≤ sizeof(long) ≤ sizeof(long long)
•1 ≤ sizeof(bool) ≤ sizeof(long)
• sizeof(char) ≤ sizeof(wchar_t) ≤ sizeof(long)
• sizeof(float) ≤ sizeof(double) ≤ sizeof(long double)
• sizeof(N) ≡ sizeof(signed N) ≡ sizeof(unsigned N)

И вот ещё

40.2.1 Limit Macros
...
CHAR_BIT Number of bits in a char (usually 8)

нет, char тоже бывает 32-битный на некоторых платформах. просто там нет ничего, кроме 32-битных адресов. и все типы одной длины.

а зачем тебе int в 64 бита? надо больше - используй long или long long. типы данных не привязаны к размерности шины. более того, большинству приложений и адресация в 64 бита не нужна даром, потому что они не работают с многогигабайтным адресным пространством.

Специально для таких как ты придумали long int.

int64_t

int64_t

не, имелось ввиду для тех, кто любит неопределенные типы
Например мне нужна максимальная ширина на целевой платформе. Юзаю long int, и в зависимости от архитектуры получаю либо 32 бита либо 64

А так-то да, я уже говорил про stdint.h

2016
не использовать stdint.h

Например мне нужна максимальная ширина на целевой платформе. Юзаю long int, и в зависимости от архитектуры получаю либо 32 бита либо 64

intmax_t ffs

максимальная ширина на целевой платформе

long int

gee, это даже не смешно

Ты нахрена зип от сервера схватила, мелкосисечная?

А ты таки разглядел на аватаре, какого размера грудь?

зип

???

Ну, это само собой, sizeof(type) не бывает нулевым :)

нет.

#include <stdio.h>

struct s {
};

int main () {
    printf ("%ld\n", sizeof (struct s));
    return 0;
}

$ gcc test.c
$ ./a.out 
0

Это правда?

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

вероятно, это были вижуалы + ia64.

Потому портирование 32-битных программ на 64 бита всегда было такой головной болью. Внезапно выяснилось, что sizeof(int) != sizeof(int*)

пустые структуры - UB

и?..

нулевой sizeof - не по стандарту

Юзаю long int, и в зависимости от архитектуры получаю либо 32 бита либо 64

Здесь важна исключительно модель данных. В данном случае вам повезло, что на Linux принята LP64. А вот на Windows (LP32, LLP64) размер long int всегда 32 бита. Не стоит кодить на обум, а пользоваться стандартными типами вроде intptr_t.

как многогранен, оказывается, наш мир=)

пустые структуры - UB

UB - часть стандарта, и даже значительная часть стандарта.

Ну хоть не systemd.

clang такие же результаты выдает. Насколько помню, эти ребята (разрабы clang) оч строго стараются придерживаться стандартов, но надо почитать на самом деле.

С другой стороны, clang++ выдает sizeof(struct s)=1.

С другой стороны, clang++ выдает sizeof(struct s)=1.

Потому-что в стандарте С++ это не сделали UB, а явно выписали ограничение. Чтоб не было ситуации, когда два объекта имеют один и тот же адрес, т.к., например, при аллокации счетчик остался на месте и вернул одно и тоже значение.

Насколько помню, эти ребята (разрабы clang) оч строго стараются придерживаться стандартов

Разработчики стандарта С в данном случае умыли руки. А ребята из clang вероятно повторяли в таких случаях поведение gcc.

char, int и double везде одной и той же длины

враньё. а разгадка сабжа проста: x86_64 — не настоящий 64. на настоящем, длина инта вполне будет 8 байт.

для таких вещей есть int8_t int32_t и int64_t

Они ещё совместимости с gcc стараются придерживаться.

Если компилировать с -pedantic, то будет предупреждение.

для таких вещей есть int8_t int32_t и int64_t

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

не настоящий 64

Чем?

Да, я помню, автору QCat патч отправлял, который лечил сборку на amd64...

Makes sense. В архитектуре x86_64 операнды по умолчанию 32-битные (а вот адреса — 64-битные).