指向固定大小数组行为的指针

Question

为什么这样工作？

uint8_t array[4] = {1,2,3,4};
uint8_t* parray = array;
uint8_t (*p1)[4]  = (uint8_t (*)[4])&array;
uint8_t (*p2)[4]  = (uint8_t (*)[4])&parray;
uint8_t (*p3)[4]  = (uint8_t (*)[4])parray;
uint8_t test1 = **p1;    // test1 = 1
uint8_t test2 = **p2;    // test2 = something random
uint8_t test3 = **p3;    // test3 = 1

parray 显然与 array 几乎相同。例如，array[0] == parray[0]。但是当我想得到指向array的指针作为指向固定大小数组的指针时，我必须使用&符号。当我想获得指向 parray 的指针时，我不能。

实例.

有接受指向固定大小数组的指针的函数

void foo(uint8_t (*param)[4])
{
    ...
}

当我在另一个函数中获取参数作为指针时，我可以通过这种方式将它传递给foo吗？

void bar(uint8_t param*)
{
    uint8_t (*p)[4]  = (uint8_t (*)[4])param;
    foo(p);
}

有没有更好的方法？

Answer 1

赋值语句，

  uint8_t (*p2)[4]  = (uint8_t (*)[4])&parray;

以后做

  uint8_t test2 = **p2;

违反了严格的别名。

详细说明，&parray 是 uint8_t** 类型，您将其转换为 (uint8_t (*)[4]) 类型（它们都不是兼容类型）并且您尝试取消引用目标指针。这导致 undefined behavior.

相关，C11，章节 §6.5/P7

An object shall have its stored value accessed only by an lvalue expression that has one of the following types: ⁸⁸⁾

— a type compatible with the effective type of the object,

— a qualified version of a type compatible with the effective type of the object,

— a type that is the signed or unsigned type corresponding to the effective type of the object,

— a type that is the signed or unsigned type corresponding to a qualified version of the effective type of the object,

— an aggregate or union type that includes one of the aforementioned types among its members (including, recursively, a member of a subaggregate or contained union), or

— a character type.

Answer 2

这是一个称为数组衰减的功能。当在值上下文中使用变量名称时，据说数组变量衰减为指向第一个元素的指针。

此处数组在值上下文中使用：parray = array，因此它会衰减。你可以明确地写出衰减：parray = &(array[0])。前者（隐式衰减）只是后者的语法糖。

addressof 运算符的操作数不是值上下文。因此，数组名称不会衰减。&array 不同于 &(array[0])。首先获取数组类型的地址，后者获取元素类型的地址。而parray是一个完全不同的变量，&parray returns是指针存放的地址，不是数组存放的地址。

uint8_t (*p1)[4]  = (uint8_t (*)[4])&array;

这是正确的，尽管转换是多余的，因为 &array 已经是 uint8_t (*)[4] 类型。

uint8_t (*p2)[4]  = (uint8_t (*)[4])&parray;

这是错误的。 parray 是 uint8_t* 类型，并且存储它的地址不包含 uint8_t[4] 类型的对象。相反，它包含指针。

uint8_t (*p3)[4]  = (uint8_t (*)[4])parray;

这有点可疑。 parray 是指向 uint8_t 的指针，而不是指向 uint8_t[4] 的指针。但是，它恰好指向一个地址，该地址也包含一个 uint8_t[4] 对象，所以这是可行的。

parray is obviously nearly the same as array

但显然不完全相同，正如您程序的行为所证明的那样。

array是四个uint8_t元素的数组，parray是指向uint8_t的指针，指向array的第一个元素.理解这种区别很重要。

结论：了解数组衰减是什么，数组和指针之间的区别是什么很重要，最重要的是：显式转换可以隐藏编译器的错误 - 尽可能避免它们。

编辑：

When I get the param in another function as a pointer, can I pass it to foo this way?

只有你能证明param指向a的第一个元素 uint8_t[4]。这本质上是 bar.

的先决条件

但是，当您可以使用类型系统来传达需求时，最好不要依赖口头前提条件：

Is there a better way?

更改bar的参数类型，让用户知道传递正确类型的指针：

void bar(uint8_t (*param)[4]) {
    foo(param);
}

当然，这使得 bar 在这个简单的例子中变得多余。

Answer 3

"parray 显然与 array 几乎相同" <- 这部分不正确

存在从 array 类型到 parray 类型的隐式转换，这样初始化（或赋值），例如uint8_t* parray = array; 将 parray 设置为等于 &array[0]。相反方向不存在转换。

在 p1 p2 p3 的初始化中，您使用强制转换

掩盖了表达式的类型

uint8_t (*p1)[4]  = (uint8_t (*)[4])&array;

这里的cast是多余的，&array已经是(uint8_t (*)[4])

uint8_t (*p2)[4]  = (uint8_t (*)[4])&parray;

这里的演员是一个谎言，&parray是一个uint8_t**

uint8_t (*p3)[4]  = (uint8_t (*)[4])parray;

这里的转换是安全的，只是因为 parray

的值

Answer 4

But when I want to get the pointer to the array as the pointer to the fixed size array, I must use & symbol.

这里你的陈述在特定情况下是完全错误的，在一般情况下是半错的。您已经获得它并分配给指针变量 parray，然后...试图将该变量的地址视为指向数组的指针？在特定情况下，数组名称会衰减为指向数组的指针。通常，指向数组的指针与指向数组第一个元素的指针相同，因此您可以使用 &array[0] 或仅使用 array

指向固定大小数组行为的指针

Pointer to fixed size array behaviour

c

c++

arrays

pointers

strict-aliasing