是否可以在不使用malloc的情况下返回指向结构的指针？

Question

I'm writing a Gameboy ROM using the GBDK, which has an unstable version of malloc that I'm unable to get working. I'm also unable to return a struct within a struct. That leaves me trying to return a pointer, which is why I'm wondering if there is a way to avoid using malloc when returning a struct pointer?

What I'm basically trying to do is that I want to be able to write something like this:

create_struct(struct_name, char member_x, char member_y);

This is the code I have written using malloc:

 struct point {
    char member_x;
    char member_y;
};


struct point *makepoint(char member_x, char member_y) {
    struct point *temp = malloc(sizeof(struct point));

    temp->member_x = member_x;
    temp->member_y = member_y;

    return temp;
};

Answer 1

There are various valid ways to return a pointer (to a struct, or any type of object), but the only way to return a pointer to a new object that didn't exist before the function was called is to use malloc , realloc , calloc , aligned_alloc (C11), or some implementation-defined allocation function (eg mmap on POSIX systems, etc.).

Other ways you could return a valid pointer include:

1. A pointer to an object with static storage duration. Only once instance of such an object exists, so this is usually a bad way.

2. A pointer that was passed to the function as an argument for use as a place to store the result. This can often be a good approach, since you pass off responsibility for obtaining the storage to the caller.

3. A pointer to an object obtained from some sort of global pool. This could be a very good approach in embedded systems and game design for low-end gaming devices.

Answer 2

Is it possible to return a pointer to a struct without using malloc?

I. Technically, yes. You can make your struct static so that it survives function calls:

struct foo *bar()
{
    static struct foo f = { 1, 2, 3 };
    return &f;
}

But I doubt you actually want to do this (since this has funny side effects, read up on the meaning of the static keyword). You have several different possibilities:

II. The approach what the C standard library takes is always making the caller implicitly responsible for providing the struct and managing memory. So instead of returning a pointer, the function accepts a pointer to struct and fills it:

void dostuff(struct foo *f)
{
    foo->quirk = 42;
}

III. Or return the struct itself, it doesn't hurt, does it (it can even be move-optimized):

struct foo bar()
{
    struct foo f = { 1, 2, 3 };
    return f;
}

So, choose your poison.

Answer 3

just do something like:

void makepoint(struct point *dest, char member_x, char member_y) {
     dest->member_x = member_x; // you had these wrong in your code, by the way
     dest->member_y = member_y;
}

The structure will need to be "allocated" elsewhere (probably on the stack is your best bet).

Answer 4

You could pass the struct as a parameter and have the function initialize it :

struct point *makepoint(struct point *pt, char x, char y) {
    pt->x = x;
    pt->y = y;
    return pt;
}

and then call it like this :

struct point pt;
makepoint(&pt, 'a', 'b');

but then you might as well just have done :

struct point pt = { 'a', 'b' };

Answer 5

Note that in this case ( struct point only occupies 2 bytes) you can return struct point instead of struct point * , (this should not be done with large structs)

#include <stdio.h>

struct point {
    char member_x;
    char member_y;
};

struct point makepoint(char member_x, char member_y)
{
    struct point temp;

    temp.member_x = member_x;
    temp.member_y = member_y;
    return temp;
}

int main(void)
{
    struct point t = makepoint('a', 'b');

    printf("%c %c\n", t.member_x, t.member_y);
    return 0;
}

Answer 6

If it is not possible to get malloc() fixed, then you may just want to manage your own pre-allocated points, and limit the number of points that can be "created". You would need to alter your points a little to allow for easier management:

union free_point {
    union free_point *next;
    struct point data;
};

union free_point free_point_pool[MAX_POINTS];
union free_point *free_point_list;

struct point *makepoint(char member_x, char member_y) {
    static int i;
    union free_point *temp;

    temp = 0;
    if (i == MAX_POINTS) {
        if (free_point_list) {
            temp = free_point_list;
            free_point_list = temp->next;
        }
    } else {
        temp = free_point_pool + i++;
    }

    if (temp) {
        temp->data.x = x;
        temp->data.y = y;
    }

    return &temp->data;
};

Then, instead of calling free() on the result returned by makepoint() , you should create a new function to place it on the free_point_list .

void unmakepoint (struct point *p) {
    union free_point *fp = (union free_point *)p;
    if (fp) {
        fp->next = free_point_list;
        free_point_list = fp;
    }
}

Answer 7

The simplest thing is just to return a structure that has been created using named initializers, and do so in an inline function, so that there is zero overhead:

static inline struct point makepoint(char x, char y) {
  return (struct point) { .x = x, .y = y };
}

Then you can call it like this:

struct point foo = makepoint(10, 20);

Couldn't be simpler!