Как определить, выровнена ли память?

РЕДАКТИРОВАТЬ: приведение к long - дешевый способ защитить себя от наиболее вероятной возможности того, что int и указатели в настоящее время имеют разные размеры.

Как указано в комментариях ниже, есть лучшие решения, если вы хотите включить заголовок ...

Указатель p выравнивается по 16-байтовой границе, если ((unsigned long)p & 15) == 0.

#define is_aligned(POINTER, BYTE_COUNT) \
    (((uintptr_t)(const void *)(POINTER)) % (BYTE_COUNT) == 0)

Преобразование в void * (или, эквивалентно, char *) необходимо, потому что стандарт гарантирует только обратимое преобразование в uintptr_t для void *.

Если вам нужна безопасность типов, подумайте об использовании встроенной функции:

static inline _Bool is_aligned(const void *restrict pointer, size_t byte_count)
{ return (uintptr_t)pointer % byte_count == 0; }

и надейтесь на оптимизацию компилятора, если byte_count - константа времени компиляции.

Почему нам нужно преобразовывать в void * ?

Язык C допускает различные представления для разных типов указателей, например, у вас может быть 64-битный тип void * (все адресное пространство) и 32-битный тип foo * (сегмент).

Преобразование foo * -> void * может включать фактическое вычисление, например добавление смещения. Стандарт также оставляет на усмотрение реализацию того, что происходит при преобразовании (произвольных) указателей в целые числа, но я подозреваю, что это часто реализуется как noop.

Для такой реализации foo * -> uintptr_t -> foo * будет работать, но foo * -> uintptr_t -> void * и void * -> uintptr_t -> foo * - нет. Вычисление выравнивания также не будет работать надежно, потому что вы проверяете выравнивание только относительно смещения сегмента, которое может быть, а может и не быть тем, что вы хотите.

В заключение: всегда используйте void *, чтобы добиться независимого от реализации поведения.

В других ответах предлагается операция И с установленными младшими битами и сравнение с нулем.

Но более простой тест - выполнить MOD с желаемым значением выравнивания и сравнить его с нулем.

#define ALIGNMENT_VALUE     16u

if (((uintptr_t)ptr % ALIGNMENT_VALUE) == 0)
{
    // ptr is aligned
}

С шаблоном функции, например

#include <type_traits>

template< typename T >
bool is_aligned(T* p){
    return !(reinterpret_cast<uintptr_t>(p) % std::alignment_of<T>::value);
}

вы можете проверить выравнивание во время выполнения, вызвав что-то вроде

struct foo_type{ int bar; }foo;
assert(is_aligned(&foo)); // passes

Чтобы проверить, что неправильное выравнивание не удается, вы можете сделать

// would almost certainly fail
assert(is_aligned((foo_type*)(1 + (uintptr_t)(&foo)));

Это в основном то, что я использую. Делая целое число шаблоном, я увеличиваю время компиляции, поэтому я не буду выполнять медленную операцию по модулю, что бы я ни делал.

Мне всегда нравится проверять вводимые данные, отсюда и утверждение времени компиляции. Если ваше значение выравнивания неверно, то оно не будет компилироваться ...

template <unsigned int alignment>
struct IsAligned
{
    static_assert((alignment & (alignment - 1)) == 0, "Alignment must be a power of 2");

    static inline bool Value(const void * ptr)
    {
        return (((uintptr_t)ptr) & (alignment - 1)) == 0;
    }
};

Чтобы узнать, что происходит, вы можете использовать это:

// 1 of them is aligned...
int* ptr = new int[8];
for (int i = 0; i < 8; ++i)
    std::cout << IsAligned<32>::Value(ptr + i) << std::endl;

// Should give '1'
int* ptr2 = (int*)_aligned_malloc(32, 32);
std::cout << IsAligned<32>::Value(ptr2) << std::endl;

Оставьте это профессионалам,

https://www.boost.org/doc/libs/1_65_1/doc/html/align/reference.html#align.reference.functions.is_aligned.

bool is_aligned(const void* ptr, std::size_t alignment) noexcept; 

пример:

        char D[1];
        assert( boost::alignment::is_aligned(&D[0], alignof(double)) ); //  might fail, sometimes

Можете ли вы просто «и» ptr с 0x03 (выровнен по 4s), 0x07 (выровнен по 8s) или 0x0f (выровнен по 16s), чтобы увидеть, установлен ли какой-либо из младших битов?

Как насчет:

void *mem = malloc(1024+15); 
void *ptr =( (*(char*)mem) - (*(char *)mem % 16) );