Início / coding / Perguntas / 79574030
Accepted
stefan
Asked: 2025-04-15 05:30:48 +0800 CST

Problemas com membros de matriz flexíveis com alinhamento e aliasing estrito

  • 772
struct Node {
  Node *left;
  Node *right;
  int height;
  char data[];
};

É assim que eu costumava definir os nós da minha estrutura de dados. Acho muito útil porque posso incorporar os dados diretamente no nó; caso contrário, teria que usar um void*, o que implicaria em outro malloc e outra camada de indireção. No entanto, li que há dois problemas com esse tipo de código:

  1. Alinhamento

    Digamos que eu tenha uma função que copia alguns dados para o array de dados com memcpy. Se esses dados forem um "long" (longo), por exemplo, eles estariam desalinhados.

    _Alignas(max_align_t) char data[];

    consertar o problema?

  2. Aliasing estrito

    A questão é: contanto que eu acesse o array de dados com um ponteiro para um tipo que coincide com o tipo do objeto do qual copiei, a regra de aliasing estrito é obedecida, mesmo que eu teoricamente acesse um array de caracteres por meio de um ponteiro int, por exemplo? Este foi o único caso em que tive que lidar com código do tipo trocadilho.

c

2 respostas

  1. Best Answer

    Se você fizer ambas as coisas, ou seja, garantir que o membro da matriz flexível esteja alinhado ao máximo e acessar esse membro somente por meio de um ponteiro para o tipo do qual os dados foram copiados e alocar espaço dinamicamente, o comportamento será bem definido.

    A Seção 6.5p6 do padrão C descreve o que acontece neste caso:

    O tipo efetivo de um objeto para um acesso ao seu valor armazenado é o tipo declarado do objeto, se houver. 98) Se um valor for armazenado em um objeto sem tipo declarado por meio de um lvalue com um tipo que não seja um tipo de caractere, o tipo do lvalue se torna o tipo efetivo do objeto para esse acesso e para acessos subsequentes que não modificam o valor armazenado. Se um valor for copiado para um objeto sem tipo declarado usando memcpyor memmove, ou for copiado como uma matriz de tipo de caractere, o tipo efetivo do objeto modificado para esse acesso e para acessos subsequentes que não modificam o valor é o tipo efetivo do objeto do qual o valor é copiado, se houver um. Para todos os outros acessos a um objeto sem tipo declarado, o tipo efetivo do objeto é simplesmente o tipo do lvalue usado para o acesso.

    ...

    98) Objetos alocados não têm tipo declarado.

    As seções em negrito são relevantes aqui. Veremos exatamente como isso se aplica no exemplo abaixo, supondo que o especificador de alinhamento seja aplicado ao datamembro:

    long arr[3] = { 0x0102030405060708L, 0x0807060504030201L, -1L };
struct Node *node = malloc(sizeof(struct Node) + sizeof arr);

memcpy(node->data, arr, sizeof arr);
long *ptr = (long *)node->data;

printf("size=%zu\n", sizeof(struct Node));
for (int i=0; i<3; i++) {
    printf("ptr[%i]=%lx\n", i, ptr[i]);
}
for (int i=0; i<3*sizeof(long); i++) {
    printf("node->data[%i]=%hhx\n", i, node->data[i]);
}

    Primeiro, o espaço é alocado dinamicamente para a struct Nodemais 3 objetos do tamanho de a longe atribuídos a node. Imediatamente após a alocação, os bytes alocados não têm tipo declarado, conforme a nota de rodapé 98.

    Após a chamada para memcpy, os sizeof(long)*3bytes que começam em node->datasão um objeto com um tipo efetivo de long[3]conforme a seção em negrito, e o especificador de alinhamento no datamembro garante que esse objeto esteja alinhado corretamente.

    A atribuição a ptrnow resulta neste ponteiro apontando para o primeiro elemento do long[3]objeto que foi copiado via memcpy. O acesso subsequente a esses objetos por desreferenciação ptrvia sintaxe de indexação de array ocorre então por meio de um lvalue correspondente ao tipo dos objetos e, portanto, é válido.

    Além disso, o segundo loop, que acessou o array copiado diretamente por meio do datamembro, também é válido, pois sempre permite o acesso a bytes de um objeto por meio de um tipo de caractere. Observe que isso se aplica apenas a leituras, pois as gravações alterariam o tipo efetivo do objeto.

    A Seção 6.5p7 especifica como um objeto pode ser acessado, com as duas seções em negrito sendo relevantes aqui:

    Um objeto deve ter seu valor armazenado acessado somente por uma expressão lvalue que tenha um dos seguintes tipos:

    • um tipo compatível com o tipo efetivo do objeto,
    • uma versão qualificada de um tipo compatível com o tipo efetivo do objeto,
    • um tipo que é o tipo assinado ou não assinado correspondente ao tipo efetivo do objeto,
    • um tipo que é o tipo assinado ou não assinado correspondente a uma versão qualificada do tipo efetivo do objeto,
    • um tipo agregado ou de união que inclui um dos tipos acima mencionados entre seus membros (incluindo, recursivamente, um membro de um subagregado ou união contida), ou
    • um tipo de personagem.
    • 7

  2. Resolveria _Alignas(max_align_t) char data[];o problema?

    Sim.

    struct Node { Node *left; Node *right; int height; _Alignas(max_align_t) char data[]; };permite que qualquer objeto de tipo fundamental seja armazenado com alinhamento correto em data[].

    Considere também size_t heighto dimensionamento e a indexação do array. int heightPode ser muito pequeno.

    • 0

relate perguntas