这些类型的声明意味着什么

为了清楚起见，让我们分别看一下它们：

1. const struct aiocb *const aiocb_list[]:

   • const应用于 ：这表示中的指针指向常量结构对象，允许您使用这些指针以只读方式访问数据。struct aiocbaiocb_listaiocb
   • const应用于：数组本身是常量;存储在其中的指针无法更改。aiocb_list

2. const struct timespec *restrict timeout:

   • const应用于：指向的数据是常量（只读）。struct timespectimeout
   • restrict应用于 ：提示编译器没有别名（没有指向同一内存的其他指针），允许进行某些优化。timeout

注： 对于 applied to ，这不会阻止相同对象的非常量视图存在于程序中的其他位置。对象本身本质上不是恒定的或只读的，而是通过这些指针强制执行只读视图。conststruct aiocbaiocb_list

[1]const struct aiocb* const aiocb_list[];

这里

• aiocb_list正在宣布。它是一个数组。
• 它是一个常量数组
• 常量是指针
• 数组的每个元素都是指向 的指针，一个aiocbstruct
• 数组本身也是常数，因为第一个const
• 由于它没有被初始化，所以它必须是某些东西的一部分，比如参数列表，因为它是声明的const

因此，它是一个指向conststruct

例

这是一个使用这种结构的程序

输出

  function got 4 pointers
  Values are
  S
  O
  S
  O

法典

#include <stdio.h>

struct aiocb
{
    char what;
};

struct aiocb* action(
    size_t size, const struct aiocb* const aiocb_list[]);

int main(void)
{

    const struct aiocb data[4] = {
        [0] = {'a'},
        [1] = {'O'},
        [2] = {'S'},
        [3] = {'d'},
    };

    const struct aiocb* const list[] = {
        &data[2],
        &data[1],
        &data[2],
        &data[1],
        &data[0]
    };
    action(4, list);
    return 0;
}

struct aiocb* action(
    size_t size, const struct aiocb* const aiocb_list[])
{
    printf(
        "    function got %llu pointers\n    Values are\n",
        size);
    for (size_t i = 0; i < size; i += 1)
        printf("    %c\n", aiocb_list[i]->what);
    return NULL;
}

第二个例子：使用typedef

这是相同的代码，只是对 .一般来说，它更容易阅读并节省大量打字typedefstructstruct aiocb

#include <stdio.h>

typedef struct
{
    char what;
} Aiocb;

Aiocb* action(size_t, const Aiocb* const[]);

int main(void)
{
    const Aiocb data[4] = {
        [0] = {'a'},        [1] = {'O'},
        [2] = {'S'},        [3] = {'d'},
    };

    const Aiocb* const list[] = {
        &data[2], &data[1], &data[2], &data[1], &data[0]};
    action(4, list);
    return 0;
}

Aiocb* action(
    size_t size, const Aiocb* const aiocb_list[])
{
    printf(
        "    function got %llu pointers\n    Values are\n",
        size);
    for (size_t i = 0; i < size; i += 1)
        printf("    %c\n", aiocb_list[i]->what);
    return NULL;
}

请注意，这些赋值main

    list[0] = NULL; // error: array elements are const
    const Aiocb* other[5] = {0};
    // error: list can not point to other places
    list = other; 

不会编译，因为所有数组元素都是并且也是constlistconst

[2]const struct timespec *restrict timeout;

此处被声明为指向 .并且是恒定的。timeouttimespecstruct

restrict是程序员的承诺，即在其生命周期内，如此声明的指针将是唯一访问其目标的指针。对目标的访问仅限于此指针。

此保证为编译器提供了优化代码的机会。

一个很好的例子是 cppreference：

int foo(int *a, int *b)
{
    *a = 5;
    *b = 6;
    return *a + *b;
}
 
int rfoo(int *restrict a, int *restrict b)
{
    *a = 5;
    *b = 6;
    return *a + *b;
}

以及可能生成的代码

; generated code on 64bit Intel platform:
foo:
    movl    $5, (%rdi)    ; store 5 in *a
    movl    $6, (%rsi)    ; store 6 in *b
    movl    (%rdi), %eax  ; read back from *a in case previous store modified it
    addl    $6, %eax      ; add 6 to the value read from *a
    ret
 
rfoo:
    movl      $11, %eax   ; the result is 11, a compile-time constant
    movl      $5, (%rdi)  ; store 5 in *a
    movl      $6, (%rsi)  ; store 6 in *b
    ret

我们看到，编译器知道除了 和 之外没有人指向函数内部的目标，可以返回并跳过之前的返回。ab11add

在某些情况下，可以大大节省执行时间和代码大小，因为编译器可以在大型循环中重新排序或跳过操作。restrict