对有效的类型规则感到困惑

我似乎再次错过了有关有效类型的一些难题......代码中的注释本质上是我的问题，但这是我能想到在适当的上下文中提出这个问题的唯一方法。

#include <stdlib.h>
#include <string.h>

typedef struct foo {
    int n;
} Foo;

int main(void)
{
    // No effective type yet because there has been no write to the memory.
    Foo *f = malloc(sizeof(Foo));

    // Effective type of `f` is now `Foo *`, except I'm writing to
    // `f->n`, so shouldn't it be `int *`? Not sure what's going on here.
    f->n = 1;

    // No effective type yet because there has been no write to the memory.
    char *buf = malloc(sizeof(Foo));

    // Effective type of `buf` is `Foo *`, despite it being declared as
    // `char *`.
    // It's not safe to modify `buf` as a `char` array since the effective type
    // is not `char`, or am I missing something?
    memcpy(buf, f, sizeof(Foo));

    // The cast here is well defined because effective type of `buf` is
    // `Foo *` anyway, right?
    ((Foo *)buf)->n++;

    // I'm not even sure this is OK. The effective type of `buf` is `Foo *`,
    // right? Why wouldn't it be OK then?
    memcpy(f, buf, sizeof(Foo));

    // Safe if the last `memcpy` was safe.
    f->n++;

    // buf now points to invalid memory.
    free(buf);

    // Pointers with different declared types point to the same object,
    // but they have the same effective type that is not qualified by
    // `restrict`, so this doesn't violate strict aliasing, right?
    // This is allowed because `f` was allocated via `malloc`,
    // meaning it is suitably aligned for any data type, so
    // the effective type rules aren't violated either.
    buf = (void *)f;

    // `f`, and consequently `buf` since it points to the same object as `f`,
    // now point to invalid memory.
    free(f);
}

我认为所有这些都可以是正确的，还是在某些情况下我是错误的？我意识到这是在问多个问题，但我本质上是在问我对有效类型和严格别名的理解是否正确。 GCC 没有为我提供任何诊断信息-pedantic-errors -Wextra -Wall -O2 -fstrict-aliasing -Wstrict-aliasing

您似乎对“有效类型”的适用范围感到困惑：它适用于 malloc 空间，而不是任何指针。与 C 中一样，指针是一个单独的对象，具有指向指针可能指向的任何空间的单独属性。

f是一个（命名）变量，因此其有效类型始终与其声明类型相同，即Foo *。相似地buf的有效类型始终是char *。有效类型在运行时可能改变的唯一一次是动态分配的空间。

您的要点和代码注释没有什么意义，因此我决定重新注释您的代码。在每种情况下，文本均指文本上方的代码：

Foo *f = malloc(sizeof(Foo));

好的。未初始化的字节已被分配并且f指向他们。动态分配的空间还没有有效的类型。

f->n = 1;

第一种有效类型sizeof(int)动态分配空间的字节设置为int。 （* - 但请参阅脚注）

char *buf = malloc(sizeof(Foo));
memcpy(buf, f, sizeof(Foo));

The memcpy函数保留复制对象的有效类型，因此第一个对象的有效类型sizeof(int)指向的空间的字节数buf, is int.

((Foo *)buf)->n++;

首先，演员阵容不存在对齐问题，因为malloc对于任何类型，空间都正确对齐。继续访问n，这是可以的，因为((Foo *)buf)->n是类型的左值int，它指定一个有效类型的对象int。这样我们就可以毫无问题地读写。

memcpy(f, buf, sizeof(Foo));

memcpy总是可以的，因为它设置了有效类型（您的评论表明 memcpy 在某些情况下可能不正常）。该行设置了所指向的空间的有效类型f, to int（因为源空间具有有效类型int).

f->n++;

很好，道理一样((Foo *)buf)->n++ above.

free(buf);
buf = (void *)f;

冗余演员阵容。所指向的空间f有有效类型int尽管如此，因为这两行都没有写入该空间。

free(f);

没问题。

脚注：有些人对这个表达有不同的解释f->n (or ((Foo *)buf)->nw.r.t.严格的别名。他们说f->n定义为(*f).n因此相关的有效类型是*f，不是类型f->n。我不同意这个观点，所以不再赘述。有人建议 C2X 澄清这种情况以及严格混叠的其他灰色区域。对于您的特定代码，该代码在任何一种解释下仍然是正确的。