如何在struct成员数组中应用restrict指针类型关键字？

Question

Say I have a struct defined like so:

typedef struct MyStruct {
    double a[3];
    double b[6];
} MyStruct;

I pass the structures to a function to perform some operations. For example:

void MyFcn(MyStruct *out, const MyStruct *in) {
    out->a[2] = in->b[5];
    /* do more stuff */
}

If I want to qualify the array pointers MyStruct.a and MyStruct.b as not having overlapping memory with the restrict keyword, is there any way of doing this?

Perhaps most compilers would optimize assuming that MyStruct.a and MyStruct.b point to contiguous memory block without any aliasing anyways, and there's no point in adding the restrict qualifier? I have no idea.

I know I could simply make a and b pointers instead of arrays like so

typedef struct MyStruct {
    double *restrict a;
    double *restrict b;
} MyStruct;

but considering the size of the arrays are known, this approach makes it difficult to debug overflows and unnecessarily complicates variable initializations (requires dynamic memory allocations or compound literals and designated initializers).

EDIT

From the comments below, I need to clarify that I intended for the example to better describe the question, not constrain it to that use case. The answers did clarify that struct members cannot have overlapping memory (thats' what unions are for).

However, the question still remains for different function inputs/outputs. For any number of function inputs/outputs with different struct definitions, would the compiler optimize if there are possibilities of aliased arrays between structs? If it would not, how to give the restrict keyword?

Answer 1

"If I want to qualify the array pointers MyStruct.a and MyStruct.b ...". a and b are arrays (for the first typedef), not pointers and definitive no "array pointers" - that would be something like

char a[10];
... &a ....

Also, if they are implicitly converted to a pointer, these cannot alias for the same struct . If you need distinct pointers to them, you can qualify those restrict . However, you do not use pointers to these arrays in your example code, so no need.

The only pointers which might alias are in and out . This is a matter of intended usage. I would recommend they actually should not, so you might qualify them restrict and - possibly in additionally const if applicable.

Btw: only pointer types can be restrict ed and arrays are no pointers, but decay to them for most operations.

Oh, and: If the sizes of the arrays are fixed, I agree that making the fields pointers is nonsense and just inefficient bloat.

Answer 2

out->a and in->b could overlap if out and in both point to different parts of a union that are offset by some amount.

It's not possible to use restrict on a struct member. And I would argue that that doesn't make sense anyway. How will you fulfil that guarantee?

It is sufficient to use restrict on your function parameters, which promises that no part of one struct overlaps with the other.

NB. x = y would generate the same code whether or not x and y overlap anyway.

Answer 3

I'm out a limb here having little experience with restrict . Based on study, this appears to be right. So making this wiki for all to modify.

---

Add restrict to the function parameters (and not the typedef ). By adding restrict to a pointer, the compiler may assume that only that pointer will access/change the data it points to. This allows for optimizations desired by OP as the pointers do not alias each others data.

typedef struct MyStruct {
    double a[3];
    double b[6];
} MyStruct;

void MyFcn(MyStruct * restrict out, const MyStruct *restrict in);

So now MyFcn() can assume in its use of in and out will not point to the same data. Calling code should also never do MyFcn(&data, &data) as that breaks the contract as calling code sent pointers to overlapping memory.

Some restrict specifications

An object that is accessed through a restrict-qualified pointer has a special association with that pointer. This association, ... requires that all accesses to that object use, directly or indirectly, the value of that particular pointer. The intended use of the restrict qualifier ... is to promote optimization, ... C11dr §6.7.3 8

Types other than pointer types whose referenced type is an object type shall not be restrict-qualified. §6.7.3 2

A translator is free to ignore any or all aliasing implications of uses of restrict . §6.7.3.1 6

---

Even one restrict parameter may make sense.

char buf[100];
void foo1(char * restrict p1) {
  /* foo1() knows p1 does not overlap global `buf`. */
  strcpy(buf, p1);  
}