orden - Cómo inicializar los miembros de la estructura de las estructuras en el montón

lista de etiquetas html

Question

Me gustaría asignar una estructura en el montón, inicializarlo y devolverle un puntero desde una función. Me pregunto si hay una manera para que inicialice los miembros 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 concluir de esto que es imposible asignar e inicializar una estructura en el montón que contiene miembros de const?

Answer 1

Al igual que:

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 convertir el valor de retorno de malloc en C, y a menudo se considera de mala calidad porque puede ocultar otros errores).

Answer 2

Me gusta el enfoque de caf , pero esto me sucedio tambien

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;
}

Answer 3

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 4

Si insistes en mantener la const en la estructura, vas a tener que hacer algo de fundición para evitar eso:

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