我刚完成了一次工作面试的测试，其中有一个问题让我束手无策，即使使用谷歌也没能找到答案。现在请看看StackOverflow的大佬们能做什么:
memset_16aligned函数要求传递给它一个16字节对齐的指针，否则会崩溃。a) 如何分配1024字节的内存，并将其对齐到16字节的边界？
b) 在执行memset_16aligned后释放内存。
{
void *mem;
void *ptr;
// answer a) here
memset_16aligned(ptr, 0, 1024);
// answer b) here
}
{
void *mem = malloc(1024+16);
void *ptr = ((char *)mem+16) & ~ 0x0F;
memset_16aligned(ptr, 0, 1024);
free(mem);
}
{
void *mem = malloc(1024+15);
void *ptr = ((uintptr_t)mem+15) & ~ (uintptr_t)0x0F;
memset_16aligned(ptr, 0, 1024);
free(mem);
}
第一步是分配足够的备用空间，以防万一。由于内存必须对齐16字节（也就是说，前导字节的地址必须是16的倍数），额外添加16字节可以确保我们有足够的空间。在前16个字节中，有一个16字节对齐的指针。（请注意，malloc() 应该返回一个对于任何目的都足够对齐的指针。但“任何”需要主要针对基本类型，如 long、double、long double、long long，以及对象和函数的指针。如果需要进行更专业的操作，例如使用图形系统，可能需要比系统的其他部分更严格的对齐方式，这就是此类问题与答案的原因。）
下一步是将 void 指针转换为 char 指针。 除了 GCC 之外，您不应该在 void 指针上执行指针算术运算（GCC 有警告选项告诉您是否滥用了它）。 然后将起始指针增加16。 假设 malloc() 返回无法对齐的指针：0x800001。 添加16会得到 0x800011。现在我要将其向下舍入到16字节边界-因此，我要将最后4位重置为 0。 0x0F 的最后4位设置为1；因此，~0x0F 具有除最后四个以外的所有位都设置为1。对其与0x800011进行 AND 操作可以得到0x800010。您可以遍历其他偏移量并查看是否同样适用该算法。
free() 的最后一步很容易：您始终只返回 malloc()、calloc() 或 realloc() 返回给您的值，否则就会出问题。 您正确地提供了 mem 来保存该值-谢谢。 free() 释放它。
最后，如果您了解系统的 malloc 包的内部工作方式，那么您可能会猜测它可能会返回 16 字节对齐的数据（或者是 8 字节对齐）。 如果它是 16 字节对齐的，则不需要调整值。但这是不稳定和不可移植的，因为其他 malloc 包具有不同的最小对齐方式，因此假设一件事情并做另一件事情可能会导致核心转储。 在广泛的限制范围内，此解决方案是可移植的。
其他评论-此代码不检查分配是否成功。
Windows Programmer 指出指针不能进行位掩码操作，实际上，GCC（已测试3.4.6和4.3.1）确实会发出警告。因此，下面是一个基本代码的修正版本——转换为主程序。我还修改了15而不是16，正如之前指出的那样。由于C99已经存在了足够长的时间以便在大多数平台上使用，因此我正在使用 uintptr_t。如果没有在printf()语句中使用PRIXPTR，只需#include <stdint.h>即可，而无需使用#include <inttypes.h>。[这段代码包括C.R.指出的问题修复，该问题一开始由Bill K几年前就已经被指出，但我直到现在才注意到。]
#include <assert.h>
#include <inttypes.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
static void memset_16aligned(void *space, char byte, size_t nbytes)
{
assert((nbytes & 0x0F) == 0);
assert(((uintptr_t)space & 0x0F) == 0);
memset(space, byte, nbytes); // Not a custom implementation of memset()
}
int main(void)
{
void *mem = malloc(1024+15);
void *ptr = (void *)(((uintptr_t)mem+15) & ~ (uintptr_t)0x0F);
printf("0x%08" PRIXPTR ", 0x%08" PRIXPTR "\n", (uintptr_t)mem, (uintptr_t)ptr);
memset_16aligned(ptr, 0, 1024);
free(mem);
return(0);
}
以下是一个稍微更加一般化的版本，适用于大小为2的幂次方的情况：
#include <assert.h>
#include <inttypes.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
static void memset_16aligned(void *space, char byte, size_t nbytes)
{
assert((nbytes & 0x0F) == 0);
assert(((uintptr_t)space & 0x0F) == 0);
memset(space, byte, nbytes); // Not a custom implementation of memset()
}
static void test_mask(size_t align)
{
uintptr_t mask = ~(uintptr_t)(align - 1);
void *mem = malloc(1024+align-1);
void *ptr = (void *)(((uintptr_t)mem+align-1) & mask);
assert((align & (align - 1)) == 0);
printf("0x%08" PRIXPTR ", 0x%08" PRIXPTR "\n", (uintptr_t)mem, (uintptr_t)ptr);
memset_16aligned(ptr, 0, 1024);
free(mem);
}
int main(void)
{
test_mask(16);
test_mask(32);
test_mask(64);
test_mask(128);
return(0);
}
test_mask()转化为通用的分配函数，分配器的单个返回值必须编码释放地址，正如一些人在他们的答案中指出的那样。
但是，如果面试官期望其中任何一种响应，则我希望他们能认识到此解决方案回答了一个密切相关的问题，然后重新构思问题，以使对话朝正确的方向发展。（此外，如果面试官变得非常生气，那么我不想要这份工作；如果对于不够精确的要求的答案被毫不客气地打回，而没有进行更正，那么面试官就不是安全工作的人。）
最近问题的标题已经更改。 它是解决了困扰我的C内存对齐面试问题。修订后的标题（如何只使用标准库分配对齐内存？）需要稍作修改的答案-本附录为其提供。
C11（ISO / IEC 9899：2011）添加了函数aligned_alloc（）：
7.22.3.1
aligned_alloc函数Synopsis
#include <stdlib.h> void *aligned_alloc(size_t alignment, size_t size);描述
aligned_alloc函数分配一个空间，用于存储其对齐方式由alignment指定、大小由size指定且值为不确定的对象。alignment的值必须是实现支持的有效对齐方式，而size的值必须是alignment的整数倍。返回值
aligned_alloc函数返回一个空指针或者指向分配空间的指针。POSIX定义了
posix_memalign():#include <stdlib.h> int posix_memalign(void **memptr, size_t alignment, size_t size);描述
posix_memalign()函数将分配size字节，按alignment指定的边界对齐，并返回指向分配内存的指针memptr。alignment的值应为sizeof(void *)的二次幂倍数。成功完成后，
memptr指向的值应该是alignment的倍数。如果请求的空间大小为0，则行为是实现定义的;
memptr中返回的值应为null指针或唯一指针。
free()函数将释放先前由posix_memalign()分配的内存。返回值
成功完成后，
posix_memalign()将返回零; 否则，将返回错误号以指示出错。现在可以使用其中任何一个或两个来回答问题，但最初回答问题时，只有POSIX函数可用。
在幕后，新的对齐内存函数执行与问题中概述的相同工作，除了它们能够更轻松地强制对齐，并在内部跟踪对齐内存的开始，以便代码不必特别处理 - 它只释放使用的分配函数返回的内存。
<inttypes.h> 库可用（至少对于格式字符串来说是这样的——可以争论的是，值应该使用强制转换传递：(uintptr_t)mem, (uintptr_t)ptr），那么原始代码是正确的。格式字符串依赖于字符串拼接，并且 PRIXPTR 宏是 uintptr_t 值的正确 printf() 长度和类型说明符的十六进制输出。另一种选择是使用 %p，但该选项的输出因平台而异（有些会添加前缀 0x，大多数则不会），通常使用小写十六进制数字，我不喜欢；我编写的代码在各个平台上都是统一的。 - Jonathan Leffler根据不同的角度，可能会有略有不同的答案：
1) 对于这个确切的问题来说，Jonathan Leffler的解决方案足够好，但是为了向16字节对齐，你只需要额外15个字节，而不是16个。
A:
/* allocate a buffer with room to add 0-15 bytes to ensure 16-alignment */
void *mem = malloc(1024+15);
ASSERT(mem); // some kind of error-handling code
/* round up to multiple of 16: add 15 and then round down by masking */
void *ptr = ((char*)mem+15) & ~ (size_t)0x0F;
B：
free(mem);
2）为了使用更通用的内存分配函数，调用者不想跟踪两个指针（一个用于使用，一个用于释放）。因此，您将指向“真实”缓冲区下方的指针存储在对齐的缓冲区下方。
void *mem = malloc(1024+15+sizeof(void*));
if (!mem) return mem;
void *ptr = ((char*)mem+sizeof(void*)+15) & ~ (size_t)0x0F;
((void**)ptr)[-1] = mem;
return ptr;
if (ptr) free(((void**)ptr)[-1]);
long long'、'long double'、'void *' 或 'void (*)(void)'；如果包括 <stdint.h>，则可以用 'intmax_t' 代替 long long（在 Power 6（AIX）机器上，intmax_t 将为您提供一个 128 位整数类型）。该联合体的对齐要求可以通过将其嵌入到一个只有一个 char 后跟联合体的结构体中来确定：]struct alignment
{
char c;
union
{
intmax_t imax;
long double ldbl;
void *vptr;
void (*fptr)(void);
} u;
} align_data;
size_t align = (char *)&align_data.u.imax - &align_data.c;
您需要使用请求的对齐方式中更大的值（在本例中为16）和上面计算出来的 align 值。
在 Solaris 10 上（64位），malloc() 返回的结果基本对齐方式是32字节的倍数。
实际上，对齐的分配器通常会使用对齐参数而不是硬编码。因此，用户将传递他们关心的结构体的大小（或大于等于它的最小2的幂）即可。
3) 使用平台提供的内容： POSIX 上的 posix_memalign，在 Windows 上使用 _aligned_malloc。
4) 如果您使用 C11，则最干净、便携且简洁的选择是使用语言规范中引入的标准库函数aligned_alloc。
ASSERT(mem); 来检查分配结果；assert 用于捕获编程错误，而不是运行时资源的缺乏。 - hlovdalchar * 和 size_t 结合会导致错误。您需要使用类似于 uintptr_t 的东西。 - Markoposix_memalign()（仅在POSIX平台上可用）.这是一个备选方案来实现“向上取整”。虽然不是最优秀的代码，但它可以完成任务，并且这种语法比较容易记忆（而且适用于不是2的幂次方的对齐值）。uintptr_t强制转换是必须的以安抚编译器；指针算术不太喜欢除法或乘法。
void *mem = malloc(1024 + 15);
void *ptr = (void*) ((uintptr_t) mem + 15) / 16 * 16;
memset_16aligned(ptr, 0, 1024);
free(mem);
很遗憾，在C99中，似乎很难保证以任何方式对齐，以便在符合C99的任何C实现之间进行移植。为什么？因为指针不能保证是平面内存模型中想象的“字节地址”。uintptr_t的表示本身也没有得到保证, 而这本身也是一种可选类型。
我们可能知道一些实现使用一个表示void *(根据定义，也包括char *)的简单字节地址，但是按照C99的规定，它对我们程序员来说是不透明的。一种实现可以通过一个集合{segment，offset}来表示指针，其中offset在现实中具有未知的对齐方式。为什么呢？指针甚至可以是某种哈希表查找值，或者甚至是链表查找值。它可以编码边界信息。
在最近的C1X草案中，我们看到了_Alignas关键字。那可能会有所帮助。
C99给我们的唯一保证是内存分配函数将返回适合分配给指向任何对象类型的指针的指针。由于我们无法指定对象的对齐方式，因此我们无法以明确定义的便携方式实现自己的分配函数并负责对齐。
如果这种说法是错误的，那将是很好的。
aligned_alloc()函数。(C++11/14/1z仍然没有它)。_Alignas()和C++的alignas()对于动态分配并没有任何作用，只适用于自动和静态存储(或结构体布局)。 - Peter Cordes在16比15字节填充的前提下，你需要添加的实际数字以获得N对齐的最大值为max(0,N-M)，其中M是内存分配器的自然对齐方式（两者都是2的幂次方）。
由于任何分配器的最小内存对齐方式都是1字节，因此15=max(0,16-1)是一个保守的答案。但是，如果你知道你的内存分配器会给你32位整数对齐的地址（这是相当常见的），你可以使用12作为填充。
这对于本例并不重要，但在每个int都很重要的具有12K RAM的嵌入式系统中可能很重要。
如果你确实想尝试节省每个可能的字节，最好的实现方法是将其作为宏来实现，这样你就可以将其传递给本机内存对齐方式。再次强调，这仅在需要节省每个字节的嵌入式系统中才有用。
在下面的示例中，在大多数系统上，值1对于MEMORY_ALLOCATOR_NATIVE_ALIGNMENT来说已经足够好了，但对于我们理论上的具有32位对齐分配的嵌入式系统，以下内容可以节省一点宝贵的内存：
#define MEMORY_ALLOCATOR_NATIVE_ALIGNMENT 4
#define ALIGN_PAD2(N,M) (((N)>(M)) ? ((N)-(M)) : 0)
#define ALIGN_PAD(N) ALIGN_PAD2((N), MEMORY_ALLOCATOR_NATIVE_ALIGNMENT)
void my_func( void )
{
uint8_t array[1024] __attribute__ ((aligned(16)));
...
}
void *buf = NULL;
int err = posix_memalign( &buf, 32 /*alignment*/, 1024 /*size*/);
if( err )
RunInCirclesWaivingArmsWildly();
...
free(buf);
有些人提到了类似的C++界面。
不要忘记页面是按2的幂次方对齐的，因此页面对齐的缓冲区也是16字节对齐的。因此，mmap()、valloc()和其他类似的接口也是选��。如果需要，mmap()具有缓冲区可以预初始化为非零内容的优点。由于这些都具有页面对齐大小，所以您将无法从中获得最小分配，并且第一次触及它时可能会受到VM故障的影响。
Cheesy: 打开guard malloc或类似的功能。像这样大小为n * 16字节的缓冲区将是n * 16字节对齐的，因为VM用于捕获溢出，而其边界位于页面边界处。
某些Accelerate.framework函数需要用户提供一个临时缓冲区作为临时空间。在此情况下，我们不得不假设传递给我们的缓冲区被极度错位，并且用户正在积极尝试使我们的生活更加困难。 （我们的测试用例在临时缓冲区之前和之后都设置了守卫页来强调这种恶意。）在这里，我们返回所需的最小大小，以保证其中某个位置有16字节对齐的段，然后手动对齐缓冲区。该大小为desired_size + alignment-1。因此，在这种情况下，它是1024 + 16-1 = 1039字节。然后按以下方式对齐：
#include <stdint.h>
void My_func( uint8_t *tempBuf, ... )
{
uint8_t *alignedBuf = (uint8_t*)
(((uintptr_t) tempBuf + ((uintptr_t)alignment-1))
& -((uintptr_t) alignment));
...
}
添加alignment-1将把指针移动到第一个对齐地址之后，然后与-alignment进行AND运算（例如，alignment=16的情况下为0xfff...ff0），使其返回到对齐地址。
正如其他帖子所描述的，在没有16字节对齐保证的其他操作系统上，您可以使用较大的大小调用malloc，将指针保留以供稍后的free()使用，然后按照上述立即进行对齐并使用对齐的指针，就像我们的临时缓冲区案例一样。
至于aligned_memset，这是相当愚蠢的。你只需要循环不超过15个字节就能到达对齐地址，然后在那之后继续进行对齐存储，并在末尾进行一些可能的清理代码。您甚至可以在向量代码中完成清理位，无论是作为重叠对齐区域的非对齐存储（如果长度至少为向量长度），还是使用类似movmaskdqu的东西。有人只是懒惰了。但是，如果面试官想知道您是否熟悉stdint.h、位运算符和内存基础知识，那么这可能是一个合理的面试问题，因此可以原谅这个假设的示例。
unsigned char* myptr，然后计算 mptr += (16-(uintptr_t)my_ptr) & 0x0F，在定义了my_ptr的所有实现中都会定义行为，但生成的指针是否对齐取决于uintptr_t位和地址之间的映射。 - supercat