为什么转换指针会改变地址处的值？

Question

所以我正在做一个练习，看看我是否正确使用了 memset。

这是我编写的原始代码，它应该将一些地址设置为 50：

int main(){
    int *block1 = malloc(2048);
    memset(block1, 50, 10);
    // int count = 0;
    for (int *iter = block1; (uint8_t *) iter < (uint8_t *)block1 + 10; iter = (int *) ((uint8_t *)iter + 1) ){
        printf("%p : %d\n", iter, *iter);
    }
    return 0;
}

我希望 memory 中的每个地址都存储值 50。但是我的 output 是：

（地址：价值）

0x14e008800 : 842150450
0x14e008801 : 842150450
0x14e008802 : 842150450
0x14e008803 : 842150450
0x14e008804 : 842150450
0x14e008805 : 842150450
0x14e008806 : 842150450
0x14e008807 : 3289650
0x14e008808 : 12850
0x14e008809 : 50

我被困在这个问题上一段时间并尝试了很多东西，直到我随机决定也许我的指针是问题所在。 然后我尝试了一个 uint8_t 指针。

int main(){
    uint8_t *block1 = malloc(2048);
    memset(block1, 50, 10);
    for (uint8_t  *iter = block1; iter < block1 + 10; iter++ ){
        printf("%p : %d\n", iter, *iter);
    }
    return 0;
}

我所做的只是将 block1 变量和我的 iter 变量的类型更改为 uint8_t 指针而不是 int 指针，我得到了正确的结果！

0x13d808800 : 50
0x13d808801 : 50
0x13d808802 : 50
0x13d808803 : 50
0x13d808804 : 50
0x13d808805 : 50
0x13d808806 : 50
0x13d808807 : 50
0x13d808808 : 50
0x13d808809 : 50

那么我的问题是，为什么会产生如此大的差异？

Answer 1

那么我的问题是，为什么会产生如此大的差异？

因为指针的确切类型非常重要。 C 中的指针不仅仅是 memory 地址。 指针是 memory 地址，以及预期在该地址找到什么类型的数据的概念。

如果你写

uint8_t *p;
... p = somewhere ...
printf("%d\n", *p);

然后在最后一行中， *p获取p指向的 memory 的一个字节。

但是如果你写

int *p;
... p = somewhere ...
printf("%d\n", *p);

其中，是的，唯一的变化是指针的类型，然后在完全相同的最后一行中， *p现在获取p指向的 memory 的四个字节，将它们解释为 32 位int 。 （这假设你机器上的int是四个字节，这在现在很常见。）

当你打电话

memset(block1, 50, 10);

您要求将 block1 中block1的一些（尽管不是全部）单个字节设置为 50。

当您使用int指针跨过 memory 块时，一次获取（如前所述）四个字节的 memory，您会得到 4 个字节的整数，其中 4 个字节中的每一个都包含值 50。所以你的值得到了

(((((50 << 8) | 50) << 8) | 50) << 8) | 50

恰好是 842150450。

或者，换个角度看，如果你取值 842150450 并将其转换为十六进制（以 16 为基数），你会发现它是 0x32323232，其中 0x32 是十六进制值 50，再次表明我们有四个字节值 50。

现在，到目前为止，这一切都说得通，不过，你在第一个节目中如履薄冰。 你有int *iter ，但是你说

for(iter = block1; (uint8_t *) iter < (uint8_t *)block1 + 10; iter = (int *) ((uint8_t *)iter + 1) )

在那个繁琐的增量表达式中

iter = (int *) ((uint8_t *)iter + 1)

您已设法将iter中的地址仅增加一个字节。 通常，我们说

iter = iter + 1

要不就

iter++

这意味着将iter中的地址增加几个字节，以便它指向传统int int

以您的方式进行操作具有三个含义：

1. 您正在访问一种滑动 window 的int大小的block1子块。 也就是说，您获取了一个由字节 1、2、3 和 4 组成的int ，然后是一个由字节 2、3、4 和 5 组成的int ，然后是一个由字节 3、4、5 和 6 组成的int ，等等. 由于所有字节都具有相同的值，因此您总是得到相同的值，但这是一件奇怪且通常毫无意义的事情。
2. 您获取的int值中有四分之三是unaligned 。 看起来你的处理器让你摆脱了这个问题，但有些处理器会给你一个总线错误或其他类型的内存访问异常，因为并不总是允许未对齐的访问。
3. 您还违反了关于严格别名的规则。

Answer 2

function memset将提供的 memory 的每个字节设置为指定值。

所以在这个电话中

memset(block1, 50, 10);

由指针block1寻址的 memory 的10个字节被设置为值50 。

但是使用具有int *类型的指针iter您将立即输出指针指向的sizeof( int )个字节。

另一方面，如果将指针声明为具有类型

uint8_t  *iter;

那么您将 output 仅 memory 的一个字节。

考虑以下演示程序。

#include <stdio.h>

int main( void ) 
{
    int x;
    memset( &x, 50, sizeof( x ) );

    printf( "x = %d\n", x );

    for ( const char *p = ( const char * )&x; p != ( const char * )&x + sizeof( x ); ++p )
    {
        printf( "%d", *p ); 
    }
    putchar( '\n' );
}

程序 output 是

x = 842150450
50505050

即 integer 变量x占用的 memory 的每个字节设置为等于 50。

如果 output 每个字节分别输出，则程序输出值 50。

为了更清楚，再考虑一个演示程序。

#include <stdio.h>

int main( void ) 
{
    printf( "50 in hex is %#x\n", 50 );
    int x = 0x32323232;
    printf( "x = %d\n", x );
}

程序 output 是

50 in hex is 0x32
x = 842150450

也就是说，十六进制值50等于 tp 0x32 。

因此这个初始化

int x = 0x32323232;

产生与调用 function memset相同的结果

memset( &x, 50, sizeof( x ) );

你可以等效地重写

memset( &x, 0x32, sizeof( x ) );

Answer 3

在第一种情况下，您正在取消引用int* iter ，因此它会在地址处打印（未对齐的） int值，而不是字节值。

当您查看十六进制值 842150450（0x32323232）时，很清楚发生了什么，即 integer 的每个字节都是 0x32（十进制 50）。 第 10 个字节之后的字节是未定义的，但在这种情况下恰好为零，并且是目标小端序，所以它以 0x323233、0x3232 和最后 0x32 结尾。

显然第二种情况是更“正确”的解决方案，但您可以修复第一种情况；

printf("%p : %d\n", 
       (void*)iter, 
       *(uint8_t*)iter);