将char地址分配给一个int指针，然后写入一个int大小的内存

问题描述

Stroustrup-编程：使用C ++的原理和实践中的

。在§17.3中，关于内存，地址和指针，应该允许将char*分配给{{1 }}：

int*

在图形上我们有这样的东西：

引用来源：

如果编译器允许该代码，那么我们将char ch1 = 'a'; char ch2 = 'b'; char ch3 = 'c'; char ch4 = 'd'; int* pi = &ch3; // point to ch3,a char-size piece of memory *pi = 12345; // write to an int-size piece of memory *pi = 67890; 写入12345到内存中。那肯定会改变附近的一些内存的值，例如&ch3或ch2，否则我们将覆盖ch4本身的一部分。

在这种情况下，下一个分配pi将*pi = 67890放在内存的某些完全不同的部分。

---

我不明白，为什么下一个作业会将其放置在内存的某些完全不同的部分中？存储在67890中的地址仍为int *pi，因此分配将覆盖该地址处的内容，即&ch3。为什么不是这样？

请，你能帮我吗？非常感谢！

解决方法

char ch3 = 'c';
int* pi = &ch3;

应该允许将char *分配给int *：

不太正确-存在对齐问题。什么时候是未定义行为（UB）

如果结果指针未针对引用的类型正确对齐，则行为未定义。 C17dr§6.3.2.3 7

示例：某些处理器要求int *为偶数，并且如果&ch3为奇数，则存储地址可能失败，并且取消引用该地址肯定会失败：{{ 3}}。

---

由于目的地在ch3的内存之外，所以下一个肯定是UB。
ch1,ch2,ch4可能在附近并提供了一些合理的未定义行为，但结果是UB。

// undefined behavior
*pi = 12345;      // write to an int-size piece of memory`

当代码尝试在其边界之外进行写入时-它是UB，可能会发生任何事情，包括写入相邻数据。

存储在int * pi中的地址仍为＆ch3

也许，也许不是。发生了UB。

为什么下一个作业会将其放置在内存的某些完全不同的部分？

该侮辱性代码表明pi本身被*pi = 12345;覆盖。这可能会发生，可能不会。是UB。 *pi的后续使用只是更多的UB。

---

用UB调用您可能会得到希望的结果，您可能不会得到-它不是C定义的。

,

您似乎跳过了引述的部分解释：

否则我们将覆盖pi本身的一部分

这样想吧，因为int比char大，如果int*指向存储char的地址，则当您尝试为该位置分配整数值时溢出内存，因为您仅分配了一个字节的内存，但正在分配4个字节的数据。也就是说，您无法将4个字节的数据装入一个字节，因此其他3个字节将放在某处。

然后假定溢出字节部分更改了pi中存储的值。现在，下一次分配将转到随机存储位置。

,

我们假设内存地址布局为：

<ng-container *ngIf="block.type === fielType.Block">
    <app-adresat-list *ngIf="block.tag === 'ADRESATS'" [list]="block?.children">
        <ng-container *ngTemplateOutlet="children; context: { block: block }"> </ng-container>
    </app-adresat-list>
    <app-word-settings *ngIf="block.tag === 'WORD_SETTINGS'" [element]="block">
        <ng-container *ngTemplateOutlet="children; context: { block: block }"> </ng-container>
    </app-word-settings>
    <app-parameters *ngIf="block.tag === 'PARAMETERS'" [element]="block">
        <ng-container *ngTemplateOutlet="children; context: { block: block }"> </ng-container>
    </app-parameters>
    <app-document-parameters *ngIf="block.tag === 'GENERICPARAMETERS'" [element]="block">
        <ng-container *ngTemplateOutlet="children; context: { block: block }"> </ng-container>
    </app-document-parameters>
</ng-container>

<!----->

<ng-container *ngIf="block.type === fielType.Field">
    <app-field [ismultisignator]="properties?.ismultisignator" [fieldDefinition]="block" (onSelected)="onFieldSelected($event)"></app-field>
</ng-container>

<!----->

<ng-container *ngIf="block.type === fielType.Table">
    <app-postaddress *ngIf="block.tag === 'TAG_ADDR'" [element]="block"></app-postaddress>
</ng-container>

<!--------------->

<ng-template #children let-block="block">
    <ng-container *ngIf="block?.children">
        <ng-container *ngFor="let child of block.children">
            <app-document-form-node [block]="child"></app-document-form-node>
        </ng-container>
    </ng-container>
</ng-template>

从左开始，0、1、2和3是字符。从右边的4、5、6和7开始是一个int *。 十六进制的每个字节中的值可以是：

0 1 2 3 4 5 6 7

请注意前四个是ascii值，后四个是61 62 63 64 02 00 00 00 的地址。编写ch3会像这样更改值：

*pi = 12345;

61 62 39 30 00 00 00 00 为12345（小端十六进制）。

下一次写操作0x39300000将从内存地址*pi = 67890;开始，而不是人们期望的00 00 00 00。

,

首先，您必须了解所有内容都是数字，即char，int，int*都包含数字。内存地址也是数字。假设当前示例已编译，并且我们具有如下所示的内存：

--------------------------
Address | Variable | Value
--------------------------
0x01   |    ch1       a
0x02   |    ch2       b
0x03   |    ch3       c
0x04   |    ch4       d
0x05   |    pi        &ch3 = 0x03

现在让我们取消引用pi并将新值重新分配给ch3：

*pi = 12345;

我们假设int是4个字节。由于pi是int指针，它将向pi指向的位置写入一个4字节的值。现在，char只能包含一个字节值，因此，如果我们尝试向该位置写入4个字节会发生什么？严格来说，这是未定义的行为，但是我将尝试解释作者的意思。

由于char不能包含大于1个字节的值，因此*pi = 12345将溢出ch3。发生此溢出时，4个字节中的其余3个字节可能会写入附近的存储器位置。我们附近有哪些存储位置？ ch4和pi本身！ ch4也只能包含1个字节，剩下2个字节，下一个位置是pi本身。意味着pi将覆盖它自己的值！

--------------------------
Address | Variable | Value
--------------------------
0x01   |    ch1       a
0x02   |    ch2       b
0x03   |    ch3       12  //12 ended up here
0x04   |    ch4       34  //34 ended up here
0x05   |    pi        &ch3 = 0x03 // 5 gets written here

如您所见，pi现在指向其他绝对不是ch3的内存地址。