Início / coding / Perguntas / 79597848
Accepted
Fayeure
Asked: 2025-04-29 15:42:10 +0800 CST

É válido inicializar uma struct com membros const alocados na pilha com alloca?

  • 772

Considerando que o tipo Aé definido assim:

typedef struct a { const int a; } A;

Eu sei que este código é válido:

A * foo = malloc(sizeof *foo); // Allocates uninitialized memory with no effective type
memcpy(foo, &(typeof(*foo)){ .a = 42, }, sizeof *foo); // Effectively initialize the value once

(veja https://stackoverflow.com/a/79012045/13242312 )

Mas ainda é válido com allocainstead of mallocse quisermos que o valor esteja na pilha em vez do heap?

Caso de uso: Quero um único caminho de retorno em minha função, então quero definir a variável de resultado no escopo da função

A A_new(void) {
  A * a = alloca(sizeof *a);

  if (/* something */) {
    memcpy(a, &(typeof(*a)){.a = 1}, sizeof *a);
  } else {
    memcpy(a, &(typeof(*a)){.a = 2}, sizeof *a);
  }

  return *a;
}
c

1 respostas

  1. Best Answer

    Nenhuma diferença de Alloca

    O uso de allocaou mallocnão tem efeito na semântica relevante, exceto que allocanão é uma função padrão da biblioteca C.

    Sem preocupação com o tipo

    Você pode evitar questões semânticas constnão utilizando o tipo de destino ao preparar a memória. Por exemplo:

    A A_new(void)
{
    typedef typeof (A_new()) T; //  Define type T for brevity.

    void *p = alloca(sizeof (T));
    if (!p) HandleError();

    //  Memory is copied as bytes; the type T has not yet been applied to it.
    if (something)
        memcpy(p, & (T) { . a = 1 }, sizeof (T));
    else
        memcpy(p, & (T) { . a = 2 }, sizeof (T));

    //  Return an object of type T.
    return * (T *) p;
}

    O acesso à memória como tipo Tna returninstrução é definido pelo padrão C porque a memória recebeu o tipo efetivo Tao copiar nela os bytes de um Tobjeto, então ela é acessada com seu tipo efetivo.

    Não há necessidade de alocação

    Seu código de exemplo não ilustra a necessidade de usar alocação dinâmica, seja de mallocou alloca. O corpo inteiro da função poderia ser apenas:

    return (typeof (A_new())) { .a = something ? 1 : 2 };

    Percebo que o código de exemplo pode estar simplificado demais, de modo que talvez .a = something ? 1 : 2seja necessário mais do que o necessário no código original. No entanto, a alocação dinâmica ainda pode ser evitada registrando os valores dos membros em seus próprios objetos ou em uma estrutura paralela sem constmembros, como:

    A A_new(void)
{
    struct { int a; } Temporary;

    if (something)
        Temporary.a = 1;
    else
        Temporary.a = 2;

    return (typeof (A_new()) { .a = Temporary.a };
}
    • 4

relate perguntas