Re: A portable way of pointer alignment
* Pavel:
Alf P. Steinbach wrote:
But if you absolutely insist on doing it yourself,
Absolutely not :-). Vice versa, I would strongly prefer not to..
and the buffer does
not stem from an ordinary 'new' (which produces a pointer suitably
aligned for any ordinary type), and you're happy with a little formal
UB, then you might try something like
No, I can solve my problem w/o UB it for each particular situation but
it slightly have annoyed me to do it over and over again and the
maintenance have given some headache (more like thinking of it than
actually doing it :-) ); so I just wondered if anyone invented a generic
way.
<code>
typedef ptrdiff_t Size;
I am not sure every pointer fits in ptrdiff_t.. For all my target
systems I could live with C99's intptr_t though as it is supported by
their C++ compilers...
template< typename T >
inline Size alignmentOf()
{
struct X
{
char bah;
T t;
};
return offsetof( X, t );
offsetof only works when T is a POD (18.1-5). e.g. g++ gives warnings on
using it on any non-POD and we cannot allow this warning as a matter of
policy. I am not sure if it is safe even assuming GCC and flat memory
model or gcc may re-order members in non-PODs sometimes.
}
template <typename T>
T* align( char* const buf, Size const bufSize)
{
Size const i = reinterpret_cast<Size>( buf );
Size const j = i + alignmentOf<T>() - 1;
say, pointers are plain integers (flat memory model) and 0-based and (i
= reinterpret_cast<Size>) == 118 and we need to align to the 4-bytes
boundary (that is, 119 as we count from 0
No, that would be 120.
). Then, alignmentOf<T>() == 3,
No, alignmentOf would be 4 in this case (just test it if you don't believe that).
But you're right that it formally only handles POD type.
To avoid the warning you could always just do the internal formally UB pointer
arithmetic in offsetof directly, like definining your own offsetof.
(j = 118 + 3 - 1) == 120,
j = 118 + 4 - 1 == 121
Size const aligned = j - j % alignmentOf<T>();
(aligned = 118 - 118 % 3) == (118 - 1) == 117..
aligned = 121 - 121 % 4 == 121 - 1 = 120
and we expect 119 if bufSize is sufficient.
No, you expect 120 if bufSize is sufficient. ;-)
return (aligned - i >= bufSize - sizeof(T)? 0 : reinterpret_cast<T*>(
aligned ) );
But I can see where you are coming from, probably just something like
this (omitting size and null-pointer checks):
return reinterpret_cast<T *>(buf + (((intptr_t)buf - 1) /
(alignmentOf<T>() + 1)) * (alignmentOf<T>() + 1)) + 1;
?
}
</code>
(disclaimer 2: not tested! :-) )
Thanks, I did not expect it anyway, just was looking for an idea. In the
above, there are too many assumptions; I guess I will have to stick to
hand-crafting until C++0x.
Cheers & hth.,
- Alf