Cómo inicializar miembros const de estructuras en el montón

Question

Me gustaría asignar una estructura en el montón, inicializarla y devolverle un puntero desde una función. Me pregunto si hay una manera para mí para inicializar los miembros const de una estructura en este escenario:

#include <stdlib.h> 

typedef struct { 
    const int x; 
    const int y; 
} ImmutablePoint; 

ImmutablePoint * make_immutable_point(int x, int y) 
{ 
    ImmutablePoint *p = (ImmutablePoint *)malloc(sizeof(ImmutablePoint)); 
    if (p == NULL) abort(); 
    // How to initialize members x and y? 
    return p; 
} 

¿Debo deducir de esto que es imposible asignar e inicializar una estructura en el montón que contiene miembros const ?

Answer 1

así:

ImmutablePoint *make_immutable_point(int x, int y) 
{ 
    ImmutablePoint init = { .x = x, .y = y }; 
    ImmutablePoint *p = malloc(sizeof *p); 

    if (p == NULL) abort(); 
    memcpy(p, &init, sizeof *p); 

    return p; 
} 

(Tenga en cuenta que a diferencia de C++, no hay necesidad de emitir el valor de retorno de malloc en C, y que a menudo se considera de mala, ya que puede ocultar otros errores).

Answer 2

Si esto es C y no C++, no veo otra solución que subvertir el sistema de tipos.

ImmutablePoint * make_immutable_point(int x, int y) 
{ 
    ImmutablePoint *p = malloc(sizeof(ImmutablePoint)); 
    if (p == NULL) abort(); 

    // this 
    ImmutablePoint temp = {x, y}; 
    memcpy(p, &temp, sizeof(temp)); 

    // or this 
    *(int*)&p->x = x; 
    *(int*)&p->y = y; 

    return p; 
} 

Answer 3

Si insiste en mantener la const en la estructura, que van a tener que hacer algún casting para conseguir alrededor de eso:

int *cheat_x = (int *)&p->x; 
*cheat_x = 3; 

Answer 4

me gusta caf's approach, pero esto ocurrió a mí también

ImmutablePoint* newImmutablePoint(int x, int y){ 
    struct unconstpoint { 
     int x; 
     int y; 
    } *p = malloc(sizeof(struct unconstpoint)); 
    if (p) { // guard against malloc failure 
     *p.x = x; 
     *p.y = y; 
    } 
    return (ImmutablePoint*)p; 
}