vs07's questions

Tenho o seguinte script comparando o tempo que leva para declarar um objeto com uma classe em comparação diretamente com um objeto.

console.time("class decls");
class Dog {
        a;
        constructor() {
            this.a = 1;
        }
        bark() {
            this.a + this.a;
        }
    }

for (let i = 0; i < 1_000_000; ++i) {
    let dog = new Dog();
    dog.bark();
}
console.timeEnd("class decls");

console.time("object decls");
for (let i = 0; i < 1_000_000; ++i) {
    let dog = {
        a: undefined,
        bark() {
            this.a + this.a;
        }
    }
    { // inlining the constructor
        dog.a = 1;
    }
    dog.bark();
}
console.timeEnd("object decls");

Os resultados parecem favorecer fortemente o primeiro método, apresentando os seguintes tempos quando executado com Bun e resultados semelhantes quando executado com Node:

[8.46ms] class decls
[27.98ms] object decls

Por que é muito mais rápido declarar uma classe e então construir um novo objeto dela? Há algum cache acontecendo ou é outra coisa?

Estou criando um array dinâmico em C. Também quero criar uma função que inicialize um determinado array dinâmico com um certo número de elementos. Porém, ao determinar o tamanho de cada elemento para a alocação de memória, não sei exatamente o que fazer.

Aqui está o meu código:

#define typedef_list(name, type)    \
        typedef struct {            \
                int cap;            \
                int n;              \
                type *items;        \
        } name;                                                                                             

#define list_init(list, cap)                                                              \
        do {                                                                              \
                list.items = malloc(cap * sizeof(*list.items));   /* problem line */  \
                list.cap = cap;                                                        \
        } while (0);

#endif

Eu uso sizeof(*list.items)para obter o tamanho do que está sendo apontado. Parece funcionar, pois a seguinte macro funciona para um determinado tipo:

#define list_test(list) do { printf("%lu\n", sizeof(*(list.items))); } while(0);

Isso é aceitável, já que a memória ainda não foi alocada tecnicamente? Meu palpite é que o compilador não está tentando acessar essa memória e apenas "sabe" o tamanho, mas está tudo bem?

Editar - aqui está o código que uso para testar isso:

typedef_list(dyn, uint16_t);  // works with any given type

int main(void) {
        dyn arr; 
        list_test(arr);
}