BYTE* array;
BYTE* element;

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

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

F>size_t correction = alignment - 1;
F>ptr = (void*)( size_t(ptr) + correction & ~correction );
F>

unsigned align = (alignment - unsigned(ptr) % alignment) % alignment;

MS>unsigned align = (alignment - unsigned(ptr) % alignment) % alignment;
MS>

unsigned *u_ptr = (unsigned *)&ptr;
unsigned align = (alignment - *u_ptr % alignment) % alignment;

    void* ptr=0;
    size_t alignment=16;
    size_t align = (alignment - size_t(ptr) % alignment) % alignment;

    void* ptr=0;
    unsigned alignment=16;
    unsigned align = (alignment - unsigned(ptr) % alignment) % alignment;

e:\work\physic_types\physic_types.cpp(10) : warning C4311: 'type cast' : pointer truncation from 'void *' to 'unsigned int'

MS>А можно как-нибудь без size_t, а только базовыми типами обойтись? И вообще, странно, если size_t 32 бита, должно быть в точности такое же предупреждение, а если 64 — то на фиг мне такая size_t не уперлась на 32-битной платформе. Чего-то там MS компилятор мухлюет насчет size_t

size_t correction = alignment - 1;
ptr = void*( size_t(ptr) + correction & ~correction );

5.3.3 Sizeof
...
6 The result is a constant of type size_t. [Note: size_t is defined in the standard header <cstddef>(18.1). ]

Microsoft Specific

type __w64 identifier
where:

type
One of the three types that might cause problems in code being ported from a 32-bit to a 64-bit compiler: int, long, or a pointer.
identifier
The identifier for the variable you are creating.
Remarks
The __w64 keyword lets you mark variables, such that when you compile with /Wp64 the compiler will report any warnings that would be reported if you were compiling with a 64-bit compiler.

Any typedef that has __w64 on it must be 32 bits on x86 and 64 bits on ia64.

The __w64 modifier should be specified on any typedefs that change size between 32 bit and 64 bit platforms. For any such type, __w64 should appear only on the 32-bit definition of the typedef. For example:

#ifdef _WIN64
typedef unsigned __int64 size_t;
#else
typedef _W64 unsigned int size_t;
#endif
__w64 is ignored if the compilation does not use /Wp64.

Example
// __w64.cpp
// compile with: /W3 /Wp64
typedef int Int_32;
#ifdef _WIN64
typedef __int64 Int_Native;
#else
typedef int __w64 Int_Native;
#endif

int main()
{
Int_32 i0 = 5;
Int_Native i1 = 10;
i0 = i1; // C4244 64-bit int assigned to 32-bit int

// char __w64 c; error, cannot use __w64 on char
}
END Microsoft Specific

template <class T> T align(T value, unsigned char bitsCount) {
    assert(sizeof T <= bitsCount);
    T alignment = 0;
    for (unsigned char i = 0; i < bitsCount; ++i) {
        alignment <<= 1;
        alignment |= 1;
    }
    T piece = value & alignment;
    T result = value >> bitsCount;
    if (piece != 0) {
        ++result; //здесь может быть другая функция, смотря как конкретно вам нужно выравнивать
    }
    return result << bitsCount;
}

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

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

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

BYTE* array = 0;

MS>BYTE* array = 0;

void *ptr;
int *pPtr = &ptr;