Здравствуйте, McSeem2, Вы писали:

MS>Здравствуйте, JakeS, Вы писали:

MS>>>Не катит. Слова "byte order" ни о чем не говорят?

JS>>Говорят и очень много. на x86 порядок обратный, поэтому unsigned *u_ptr = (unsigned *)&ptr есть указатель на младший байт, на младшее слово, и на младшее двойное слово.

MS>Не Интелом Единым, как говорится...

ну x86 — это не только интел. Кстати а у каких процессоров по другому?

Здравствуйте, McSeem2, Вы писали:

MS>Мне надо вычислить значение выравнивания. То есть, есть массив байт и есть некий указатель внутри него, который может быть невыровненным, иметь, скажем, абстрактное значение 13. Допустим, мне надо выровнять его до 16 всегда в сторону увеличения. В данном случае — прибавить 3.

Адресная арифметика, однако:

BYTE* array;
BYTE* element;

ptrdiff_t offset = element-array;
offset = (offset + alignment-1) % alignment;
element = array + offset;

или, в одну строчку,

array + (element-array+alignment-1)%alignment

Здравствуйте, JakeS, Вы писали:

JS>Кстати а у каких процессоров по другому?

PPC, SGI, Sun, да полно. Там первый байт — это старший байт

Здравствуйте, Кодт, Вы писали:

К>Адресная арифметика, однако:
К>

К>BYTE* array;
К>BYTE* element;

К>ptrdiff_t offset = element-array;
К>offset = (offset + alignment-1) % alignment;
К>element = array + offset;
К>

К>или, в одну строчку,
К>

К>array + (element-array+alignment-1)%alignment
К>

Все правильно. Но если мне действительно потребуется выравнивание на 16 (например, для оптимизации SSE2 операций), то array сам по себе должен иметь выравнивание на 16. C++ такой гарантии не дает.
О! конгениально!

BYTE* array = 0;

Далее по тексту и никаких size_t

Здравствуйте, McSeem2, Вы писали:

MS>О! конгениально!

MS>BYTE* array = 0;

Вообще-то, адресная арифметика определена только над указателями одного и того же домена.
Нулевой указатель не принадлежит ни одному домену, поэтому с лёгкостью необычайной ты получишь UB.
Впрочем, в tiny и small моделях памяти (а виндовская flat — это 32-битный аналог tiny) это не страшно.

Здравствуйте, Кодт, Вы писали:

К>Вообще-то, адресная арифметика определена только над указателями одного и того же домена.
К>Нулевой указатель не принадлежит ни одному домену, поэтому с лёгкостью необычайной ты получишь UB.
К>Впрочем, в tiny и small моделях памяти (а виндовская flat — это 32-битный аналог tiny) это не страшно.

Ииии... тоже верно. Остаемся с size_t...

Здравствуйте, McSeem2, Вы писали:

MS>Здравствуйте, Кодт, Вы писали:

К>>Вообще-то, адресная арифметика определена только над указателями одного и того же домена.
К>>Нулевой указатель не принадлежит ни одному домену, поэтому с лёгкостью необычайной ты получишь UB.
К>>Впрочем, в tiny и small моделях памяти (а виндовская flat — это 32-битный аналог tiny) это не страшно.

MS>Ииии... тоже верно. Остаемся с size_t...

кстати, объясните такую фишку: int type
Лень лезть в стандарт. Насколько я понимаю тип int соответствует размеру регистра процессора, т.е. для 64битного процессора его размер 64бита и соответствует размеру указателя. таким образом

void *ptr;
int *pPtr = &ptr;

всегда корректно.

Здравствуйте, JakeS, Вы писали:
JS>Насколько я понимаю тип int соответствует размеру регистра процессора, т.е. для 64битного процессора его размер 64бита и соответствует размеру указателя.
Нет, не обязательно. Например, в Intel C++ IA64 (и кажется AMD64) размер int'а — 32 бита.

Здравствуйте, JakeS, Вы писали:

JS>кстати, объясните такую фишку: int type
JS>Лень лезть в стандарт. Насколько я понимаю тип int соответствует размеру регистра процессора, т.е. для 64битного процессора его размер 64бита и соответствует размеру указателя. таким образом
JS>

JS>void *ptr;
JS>int *pPtr = &ptr;
JS>

JS>всегда корректно.

Совершенно некорректно.

int соответствует размеру целочисленного регистра.
void* — представлению адреса данных для конкретной модели памяти.
void(*)() — представлению адреса кода для конкретной модели памяти.

У IA32: помимо flat модели, есть ещё сегментная, в которой адреса состоят из селектора и смещения (которое хранится в регистре общего назначения).
Аналогично — у 8086, причём в large модели адрес и указатель 32-битные (16 бит на селектор и 16 на смещение), в huge — указатель 20-битный (сплошная нумерация адресов), в small — 16 (только смещение).

На не-интеловской архитектуре — тем более бывают варианты.

Здравствуйте, Кодт, Вы писали:

К>int соответствует размеру целочисленного регистра.
Ни в коем случае нельзя на это рассчитывать. С большой вероятностью на 64-битке int будет 32-битным... я уже пример приводил.

Самый простой способ убедиться — набрать в гугле "sizeof(int) 64 bit" и посмотреть первые две ссылки.